<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP, FlexibleContexts #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE DefaultSignatures #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE GADTs #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# LANGUAGE ScopedTypeVariables #-}</span><span>
</span><span id="line-5"></span><span class="hs-pragma">{-# LANGUAGE PatternGuards #-}</span><span>
</span><span id="line-6"></span><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span class="hs-cpp">

#if __GLASGOW_HASKELL__ &gt;= 706
</span><span class="hs-pragma">{-# LANGUAGE PolyKinds #-}</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,8,0)
</span><span class="hs-cpp">#define HAS_NATURAL
</span><span class="hs-cpp">#define HAS_VOID
</span><span class="hs-cpp">#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,7,0)
</span><span class="hs-cpp">#define HAS_FIXED_CONSTRUCTOR
</span><span class="hs-cpp">#endif
</span><span>
</span><span id="line-21"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-22"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-23"></span><span class="hs-comment">-- Module      : Data.Binary.Class</span><span>
</span><span id="line-24"></span><span class="hs-comment">-- Copyright   : Lennart Kolmodin</span><span>
</span><span id="line-25"></span><span class="hs-comment">-- License     : BSD3-style (see LICENSE)</span><span>
</span><span id="line-26"></span><span class="hs-comment">--</span><span>
</span><span id="line-27"></span><span class="hs-comment">-- Maintainer  : Lennart Kolmodin &lt;kolmodin@gmail.com&gt;</span><span>
</span><span id="line-28"></span><span class="hs-comment">-- Stability   : unstable</span><span>
</span><span id="line-29"></span><span class="hs-comment">-- Portability : portable to Hugs and GHC. Requires the FFI and some flexible instances</span><span>
</span><span id="line-30"></span><span class="hs-comment">--</span><span>
</span><span id="line-31"></span><span class="hs-comment">-- Typeclass and instances for binary serialization.</span><span>
</span><span id="line-32"></span><span class="hs-comment">--</span><span>
</span><span id="line-33"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-34"></span><span>
</span><span id="line-35"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Binary.Class</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-36"></span><span>
</span><span id="line-37"></span><span>    </span><span class="annot"><span class="hs-comment">-- * The Binary class</span></span><span>
</span><span id="line-38"></span><span>      </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier">Binary</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-39"></span><span>
</span><span id="line-40"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Support for generics</span></span><span>
</span><span id="line-41"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#GBinaryGet"><span class="hs-identifier">GBinaryGet</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-42"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#GBinaryPut"><span class="hs-identifier">GBinaryPut</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-43"></span><span>
</span><span id="line-44"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Word.html#"><span class="hs-identifier">Data.Word</span></a></span><span>
</span><span id="line-47"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#"><span class="hs-identifier">Data.Bits</span></a></span><span>
</span><span id="line-48"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Int.html#"><span class="hs-identifier">Data.Int</span></a></span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Complex.html#"><span class="hs-identifier">Data.Complex</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Complex.html#Complex"><span class="hs-identifier">Complex</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#ifdef HAS_VOID
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Void.html#"><span class="hs-identifier">Data.Void</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Binary.Put.html"><span class="hs-identifier">Data.Binary.Put</span></a></span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Binary.Get.html"><span class="hs-identifier">Data.Binary.Get</span></a></span><span class="hs-cpp">

#if ! MIN_VERSION_base(4,8,0)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-identifier">Control.Applicative</span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="hs-identifier">Data.Monoid</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">mempty</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Monoid.html#"><span class="hs-identifier">Data.Monoid</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Monoid</span></span><span class="hs-cpp">
#if !MIN_VERSION_base(4,11,0)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-identifier">Data.Monoid</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-operator">&lt;&gt;</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if MIN_VERSION_base(4,8,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#"><span class="hs-identifier">Data.Functor.Identity</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier">Identity</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#if MIN_VERSION_base(4,9,0)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.List.NonEmpty.html#"><span class="hs-identifier">Data.List.NonEmpty</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">NE</span></span><span>
</span><span id="line-70"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Semigroup.html#"><span class="hs-identifier">Data.Semigroup</span></a></span><span>     </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Semigroup</span></span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.html#"><span class="hs-identifier">Data.ByteString.Lazy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier">ByteString</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-75"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.html#"><span class="hs-identifier">Data.ByteString.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">L</span></span><span>
</span><span id="line-76"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#"><span class="hs-identifier">Data.ByteString.Builder.Prim</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Prim</span></span><span>
</span><span id="line-77"></span><span>
</span><span id="line-78"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span>    </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.OldList.html#unfoldr"><span class="hs-identifier">unfoldr</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier">foldl'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-79"></span><span>
</span><span id="line-80"></span><span class="hs-comment">-- And needed for the instances:</span><span class="hs-cpp">
#if MIN_VERSION_base(4,10,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Type.Reflection.html#"><span class="hs-identifier">Type.Reflection</span></a></span><span>
</span><span id="line-83"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Type.Reflection.Unsafe.html#"><span class="hs-identifier">Type.Reflection.Unsafe</span></a></span><span>
</span><span id="line-84"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Kind.html#"><span class="hs-identifier">Data.Kind</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-85"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Exts.html#"><span class="hs-identifier">GHC.Exts</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier">RuntimeRep</span></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier">VecCount</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier">VecElem</span></span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.html#"><span class="hs-identifier">Data.ByteString</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">B</span></span><span class="hs-cpp">
#if MIN_VERSION_bytestring(0,10,4)
</span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Short.html#"><span class="hs-identifier">Data.ByteString.Short</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">BS</span></span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Map.html#"><span class="hs-identifier">Data.Map</span></a></span><span>        </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Map</span></span><span>
</span><span id="line-92"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Set.html#"><span class="hs-identifier">Data.Set</span></a></span><span>        </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Set</span></span><span>
</span><span id="line-93"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.html#"><span class="hs-identifier">Data.IntMap</span></a></span><span>     </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">IntMap</span></span><span>
</span><span id="line-94"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.html#"><span class="hs-identifier">Data.IntSet</span></a></span><span>     </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">IntSet</span></span><span>
</span><span id="line-95"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Ratio.html#"><span class="hs-identifier">Data.Ratio</span></a></span><span>      </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">R</span></span><span>
</span><span id="line-96"></span><span>
</span><span id="line-97"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#"><span class="hs-identifier">Data.Tree</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">T</span></span><span>
</span><span id="line-98"></span><span>
</span><span id="line-99"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Unboxed.html#"><span class="hs-identifier">Data.Array.Unboxed</span></a></span><span>
</span><span id="line-100"></span><span>
</span><span id="line-101"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Generics.html#"><span class="hs-identifier">GHC.Generics</span></a></span><span class="hs-cpp">

#ifdef HAS_NATURAL
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Numeric.Natural.html#"><span class="hs-identifier">Numeric.Natural</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-107"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Fixed.html#"><span class="hs-identifier">Data.Fixed</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Fixed</span></span><span>
</span><span id="line-108"></span><span>
</span><span id="line-109"></span><span class="hs-comment">--</span><span>
</span><span id="line-110"></span><span class="hs-comment">-- This isn't available in older Hugs or older GHC</span><span>
</span><span id="line-111"></span><span class="hs-comment">--</span><span>
</span><span id="line-112"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.Sequence.html#"><span class="hs-identifier">Data.Sequence</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Seq</span></span><span>
</span><span id="line-113"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#"><span class="hs-identifier">Data.Foldable</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Fold</span></span><span>
</span><span id="line-114"></span><span>
</span><span id="line-115"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Fingerprint.html#"><span class="hs-identifier">GHC.Fingerprint</span></a></span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Version.html#"><span class="hs-identifier">Data.Version</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Version.html#Version"><span class="hs-identifier">Version</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-118"></span><span>
</span><span id="line-119"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-120"></span><span>
</span><span id="line-121"></span><span class="hs-comment">-- Factored into two classes because this makes GHC optimize the</span><span>
</span><span id="line-122"></span><span class="hs-comment">-- instances faster.  This doesn't matter for builds of binary,</span><span>
</span><span id="line-123"></span><span class="hs-comment">-- but it matters a lot for end-users who write 'instance Binary T'.</span><span>
</span><span id="line-124"></span><span class="hs-comment">-- See also: https://ghc.haskell.org/trac/ghc/ticket/9630</span><span>
</span><span id="line-125"></span><span class="hs-keyword">class</span><span> </span><span id="GBinaryPut"><span class="annot"><a href="Data.Binary.Class.html#GBinaryPut"><span class="hs-identifier hs-var">GBinaryPut</span></a></span></span><span> </span><span id="local-6989586621679058477"><span class="annot"><a href="#local-6989586621679058477"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-126"></span><span>    </span><span id="local-6989586621679058476"><span id="gput"><span class="annot"><a href="Data.Binary.Class.html#gput"><span class="hs-identifier hs-type">gput</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679058477"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058476"><span class="hs-identifier hs-type">t</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span></span><span>
</span><span id="line-127"></span><span>
</span><span id="line-128"></span><span class="hs-keyword">class</span><span> </span><span id="GBinaryGet"><span class="annot"><a href="Data.Binary.Class.html#GBinaryGet"><span class="hs-identifier hs-var">GBinaryGet</span></a></span></span><span> </span><span id="local-6989586621679058464"><span class="annot"><a href="#local-6989586621679058464"><span class="hs-identifier hs-type">f</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-129"></span><span>    </span><span id="local-6989586621679058463"><span id="gget"><span class="annot"><a href="Data.Binary.Class.html#gget"><span class="hs-identifier hs-type">gget</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058464"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058463"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span class="hs-comment">-- | The 'Binary' class provides 'put' and 'get', methods to encode and</span><span>
</span><span id="line-132"></span><span class="hs-comment">-- decode a Haskell value to a lazy 'ByteString'. It mirrors the 'Read' and</span><span>
</span><span id="line-133"></span><span class="hs-comment">-- 'Show' classes for textual representation of Haskell types, and is</span><span>
</span><span id="line-134"></span><span class="hs-comment">-- suitable for serialising Haskell values to disk, over the network.</span><span>
</span><span id="line-135"></span><span class="hs-comment">--</span><span>
</span><span id="line-136"></span><span class="hs-comment">-- For decoding and generating simple external binary formats (e.g. C</span><span>
</span><span id="line-137"></span><span class="hs-comment">-- structures), Binary may be used, but in general is not suitable</span><span>
</span><span id="line-138"></span><span class="hs-comment">-- for complex protocols. Instead use the 'Put' and 'Get' primitives</span><span>
</span><span id="line-139"></span><span class="hs-comment">-- directly.</span><span>
</span><span id="line-140"></span><span class="hs-comment">--</span><span>
</span><span id="line-141"></span><span class="hs-comment">-- Instances of Binary should satisfy the following property:</span><span>
</span><span id="line-142"></span><span class="hs-comment">--</span><span>
</span><span id="line-143"></span><span class="hs-comment">-- &gt; decode . encode == id</span><span>
</span><span id="line-144"></span><span class="hs-comment">--</span><span>
</span><span id="line-145"></span><span class="hs-comment">-- That is, the 'get' and 'put' methods should be the inverse of each</span><span>
</span><span id="line-146"></span><span class="hs-comment">-- other. A range of instances are provided for basic Haskell types.</span><span>
</span><span id="line-147"></span><span class="hs-comment">--</span><span>
</span><span id="line-148"></span><span class="hs-keyword">class</span><span> </span><span id="Binary"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-var">Binary</span></a></span></span><span> </span><span id="local-6989586621679058482"><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-149"></span><span>    </span><span class="hs-comment">-- | Encode a value in the Put monad.</span><span>
</span><span id="line-150"></span><span>    </span><span id="put"><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-type">put</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span><span>
</span><span id="line-151"></span><span>    </span><span class="hs-comment">-- | Decode a value in the Get monad</span><span>
</span><span id="line-152"></span><span>    </span><span id="get"><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-type">get</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span>
</span><span id="line-153"></span><span>
</span><span id="line-154"></span><span>    </span><span class="hs-comment">-- | Encode a list of values in the Put monad.</span><span>
</span><span id="line-155"></span><span>    </span><span class="hs-comment">-- The default implementation may be overridden to be more efficient</span><span>
</span><span id="line-156"></span><span>    </span><span class="hs-comment">-- but must still have the same encoding format.</span><span>
</span><span id="line-157"></span><span>    </span><span id="putList"><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-identifier hs-type">putList</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span><span>
</span><span id="line-158"></span><span>    </span><span id="local-6989586621679057883"><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-identifier hs-var hs-var">putList</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[t] -&gt; Put
forall a. Binary a =&gt; [a] -&gt; Put
</span><a href="Data.Binary.Class.html#defaultPutList"><span class="hs-identifier hs-var">defaultPutList</span></a></span></span><span>
</span><span id="line-159"></span><span>
</span><span id="line-160"></span><span>    </span><span class="hs-keyword">default</span><span> </span><span id="put"><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-type">put</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Generics.html#Generic"><span class="hs-identifier hs-type">Generic</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#GBinaryPut"><span class="hs-identifier hs-type">GBinaryPut</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Generics.html#Rep"><span class="hs-identifier hs-type">Rep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span><span>
</span><span id="line-161"></span><span>    </span><span id="local-6989586621679057880"><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var hs-var">put</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Rep t Any -&gt; Put
forall {k} (f :: k -&gt; *) (t :: k). GBinaryPut f =&gt; f t -&gt; Put
</span><a href="Data.Binary.Class.html#gput"><span class="hs-identifier hs-var">gput</span></a></span><span> </span><span class="annot"><span class="annottext">(Rep t Any -&gt; Put) -&gt; (t -&gt; Rep t Any) -&gt; t -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; Rep t Any
forall a x. Generic a =&gt; a -&gt; Rep a x
</span><a href="../../base/src/GHC.Generics.html#from"><span class="hs-identifier hs-var">from</span></a></span></span><span>
</span><span id="line-162"></span><span>
</span><span id="line-163"></span><span>    </span><span class="hs-keyword">default</span><span> </span><span id="get"><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-type">get</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Generics.html#Generic"><span class="hs-identifier hs-type">Generic</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#GBinaryGet"><span class="hs-identifier hs-type">GBinaryGet</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Generics.html#Rep"><span class="hs-identifier hs-type">Rep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058482"><span class="hs-identifier hs-type">t</span></a></span><span>
</span><span id="line-164"></span><span>    </span><span id="local-6989586621679057872"><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var hs-var">get</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Rep t Any -&gt; t
forall a x. Generic a =&gt; Rep a x -&gt; a
</span><a href="../../base/src/GHC.Generics.html#to"><span class="hs-identifier hs-var">to</span></a></span><span> </span><span class="annot"><span class="annottext">(Rep t Any -&gt; t) -&gt; Get (Rep t Any) -&gt; Get t
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-operator hs-var">`fmap`</span></a></span><span> </span><span class="annot"><span class="annottext">Get (Rep t Any)
forall {k} (f :: k -&gt; *) (t :: k). GBinaryGet f =&gt; Get (f t)
</span><a href="Data.Binary.Class.html#gget"><span class="hs-identifier hs-var">gget</span></a></span></span><span>
</span><span id="line-165"></span><span>
</span><span id="line-166"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#defaultPutList"><span class="hs-pragma hs-type">defaultPutList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-167"></span><span id="local-6989586621679058480"><span class="annot"><a href="Data.Binary.Class.html#defaultPutList"><span class="hs-identifier hs-type">defaultPutList</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058480"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679058480"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span></span><span>
</span><span id="line-168"></span><span id="defaultPutList"><span class="annot"><span class="annottext">defaultPutList :: forall a. Binary a =&gt; [a] -&gt; Put
</span><a href="Data.Binary.Class.html#defaultPutList"><span class="hs-identifier hs-var hs-var">defaultPutList</span></a></span></span><span> </span><span id="local-6989586621679057852"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057852"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[a] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057852"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; [a] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057852"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-169"></span><span>
</span><span id="line-170"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-171"></span><span class="hs-comment">-- Simple instances</span><span class="hs-cpp">

#ifdef HAS_VOID
</span><span class="hs-comment">-- Void never gets written nor reconstructed since it's impossible to have a</span><span>
</span><span id="line-175"></span><span class="hs-comment">-- value of that type</span><span>
</span><span id="line-176"></span><span>
</span><span id="line-177"></span><span class="hs-comment">-- | @since 0.8.0.0</span><span>
</span><span id="line-178"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057846"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Void.html#Void"><span class="hs-identifier hs-type">Void</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-179"></span><span>    </span><span id="local-6989586621679057844"><span class="annot"><span class="annottext">put :: Void -&gt; Put
</span><a href="#local-6989586621679057844"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Void -&gt; Put
forall a. Void -&gt; a
</span><a href="../../base/src/Data.Void.html#absurd"><span class="hs-identifier hs-var">absurd</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span id="local-6989586621679057840"><span class="annot"><span class="annottext">get :: Get Void
</span><a href="#local-6989586621679057840"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Void
forall (m :: * -&gt; *) a. MonadPlus m =&gt; m a
</span><a href="../../base/src/GHC.Base.html#mzero"><span class="hs-identifier hs-var">mzero</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-183"></span><span class="hs-comment">-- The () type need never be written to disk: values of singleton type</span><span>
</span><span id="line-184"></span><span class="hs-comment">-- can be reconstructed from the type alone</span><span>
</span><span id="line-185"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057835"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-186"></span><span>    </span><span id="local-6989586621679057832"><span class="annot"><span class="annottext">put :: () -&gt; Put
</span><a href="#local-6989586621679057832"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Put
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span>
</span><span id="line-187"></span><span>    </span><span id="local-6989586621679057830"><span class="annot"><span class="annottext">get :: Get ()
</span><a href="#local-6989586621679057830"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; Get ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span class="hs-comment">-- Bools are encoded as a byte in the range 0 .. 1</span><span>
</span><span id="line-190"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057826"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-191"></span><span>    </span><span id="local-6989586621679057820"><span class="annot"><span class="annottext">put :: Bool -&gt; Put
</span><a href="#local-6989586621679057820"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Put) -&gt; (Bool -&gt; Word8) -&gt; Bool -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (Bool -&gt; Int) -&gt; Bool -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-192"></span><span>    </span><span id="local-6989586621679057811"><span class="annot"><span class="annottext">get :: Get Bool
</span><a href="#local-6989586621679057811"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word8 -&gt; (Word8 -&gt; Get Bool) -&gt; Get Bool
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Get Bool
forall {a} {m :: * -&gt; *}.
(Eq a, Num a, MonadFail m, Show a) =&gt;
a -&gt; m Bool
</span><a href="#local-6989586621679057809"><span class="hs-identifier hs-var">toBool</span></a></span><span>
</span><span id="line-193"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-194"></span><span>        </span><span id="local-6989586621679057809"><span class="annot"><span class="annottext">toBool :: a -&gt; m Bool
</span><a href="#local-6989586621679057809"><span class="hs-identifier hs-var hs-var">toBool</span></a></span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; m Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-195"></span><span>        </span><span class="annot"><a href="#local-6989586621679057809"><span class="hs-identifier hs-var">toBool</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; m Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-196"></span><span>        </span><span class="annot"><a href="#local-6989586621679057809"><span class="hs-identifier hs-var">toBool</span></a></span><span> </span><span id="local-6989586621679057794"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057794"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m Bool
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Could not map value &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057794"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot; to Bool&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-197"></span><span>
</span><span id="line-198"></span><span class="hs-comment">-- Values of type 'Ordering' are encoded as a byte in the range 0 .. 2</span><span>
</span><span id="line-199"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057789"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Ordering</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-200"></span><span>    </span><span id="local-6989586621679057784"><span class="annot"><span class="annottext">put :: Ordering -&gt; Put
</span><a href="#local-6989586621679057784"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Put) -&gt; (Ordering -&gt; Word8) -&gt; Ordering -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (Ordering -&gt; Int) -&gt; Ordering -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-201"></span><span>    </span><span id="local-6989586621679057778"><span class="annot"><span class="annottext">get :: Get Ordering
</span><a href="#local-6989586621679057778"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word8 -&gt; (Word8 -&gt; Get Ordering) -&gt; Get Ordering
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Get Ordering
forall {a} {m :: * -&gt; *}.
(Eq a, Num a, MonadFail m, Show a) =&gt;
a -&gt; m Ordering
</span><a href="#local-6989586621679057777"><span class="hs-identifier hs-var">toOrd</span></a></span><span>
</span><span id="line-202"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-203"></span><span>        </span><span id="local-6989586621679057777"><span class="annot"><span class="annottext">toOrd :: a -&gt; m Ordering
</span><a href="#local-6989586621679057777"><span class="hs-identifier hs-var hs-var">toOrd</span></a></span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; m Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">LT</span></span><span>
</span><span id="line-204"></span><span>        </span><span class="annot"><a href="#local-6989586621679057777"><span class="hs-identifier hs-var">toOrd</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; m Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>
</span><span id="line-205"></span><span>        </span><span class="annot"><a href="#local-6989586621679057777"><span class="hs-identifier hs-var">toOrd</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; m Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">GT</span></span><span>
</span><span id="line-206"></span><span>        </span><span class="annot"><a href="#local-6989586621679057777"><span class="hs-identifier hs-var">toOrd</span></a></span><span> </span><span id="local-6989586621679057760"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057760"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m Ordering
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Could not map value &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057760"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot; to Ordering&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-209"></span><span class="hs-comment">-- Words and Ints</span><span>
</span><span id="line-210"></span><span>
</span><span id="line-211"></span><span class="hs-comment">-- Words8s are written as bytes</span><span>
</span><span id="line-212"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-213"></span><span>    </span><span id="local-6989586621679057756"><span class="annot"><span class="annottext">put :: Word8 -&gt; Put
</span><a href="#local-6989586621679057756"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span>
</span><span id="line-214"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-215"></span><span>    </span><span id="local-6989586621679057752"><span class="annot"><span class="annottext">putList :: [Word8] -&gt; Put
</span><a href="#local-6989586621679057752"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057751"><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057751"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-216"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word8] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057751"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-217"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word8 -&gt; [Word8] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word8
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word8"><span class="hs-identifier hs-var">Prim.word8</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057751"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-218"></span><span>    </span><span id="local-6989586621679057747"><span class="annot"><span class="annottext">get :: Get Word8
</span><a href="#local-6989586621679057747"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-219"></span><span>
</span><span id="line-220"></span><span class="hs-comment">-- Words16s are written as 2 bytes in big-endian (network) order</span><span>
</span><span id="line-221"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-222"></span><span>    </span><span id="local-6989586621679057742"><span class="annot"><span class="annottext">put :: Word16 -&gt; Put
</span><a href="#local-6989586621679057742"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord16be"><span class="hs-identifier hs-var">putWord16be</span></a></span><span>
</span><span id="line-223"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-224"></span><span>    </span><span id="local-6989586621679057737"><span class="annot"><span class="annottext">putList :: [Word16] -&gt; Put
</span><a href="#local-6989586621679057737"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057736"><span class="annot"><span class="annottext">[Word16]
</span><a href="#local-6989586621679057736"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-225"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word16] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word16]
</span><a href="#local-6989586621679057736"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-226"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word16 -&gt; [Word16] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word16
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word16BE"><span class="hs-identifier hs-var">Prim.word16BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Word16]
</span><a href="#local-6989586621679057736"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-227"></span><span>    </span><span id="local-6989586621679057734"><span class="annot"><span class="annottext">get :: Get Word16
</span><a href="#local-6989586621679057734"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word16
</span><a href="Data.Binary.Get.html#getWord16be"><span class="hs-identifier hs-var">getWord16be</span></a></span><span>
</span><span id="line-228"></span><span>
</span><span id="line-229"></span><span class="hs-comment">-- Words32s are written as 4 bytes in big-endian (network) order</span><span>
</span><span id="line-230"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-231"></span><span>    </span><span id="local-6989586621679057728"><span class="annot"><span class="annottext">put :: Word32 -&gt; Put
</span><a href="#local-6989586621679057728"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord32be"><span class="hs-identifier hs-var">putWord32be</span></a></span><span>
</span><span id="line-232"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-233"></span><span>    </span><span id="local-6989586621679057723"><span class="annot"><span class="annottext">putList :: [Word32] -&gt; Put
</span><a href="#local-6989586621679057723"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057722"><span class="annot"><span class="annottext">[Word32]
</span><a href="#local-6989586621679057722"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-234"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word32] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word32]
</span><a href="#local-6989586621679057722"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-235"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word32 -&gt; [Word32] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word32
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word32BE"><span class="hs-identifier hs-var">Prim.word32BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Word32]
</span><a href="#local-6989586621679057722"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-236"></span><span>    </span><span id="local-6989586621679057720"><span class="annot"><span class="annottext">get :: Get Word32
</span><a href="#local-6989586621679057720"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word32
</span><a href="Data.Binary.Get.html#getWord32be"><span class="hs-identifier hs-var">getWord32be</span></a></span><span>
</span><span id="line-237"></span><span>
</span><span id="line-238"></span><span class="hs-comment">-- Words64s are written as 8 bytes in big-endian (network) order</span><span>
</span><span id="line-239"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-240"></span><span>    </span><span id="local-6989586621679057714"><span class="annot"><span class="annottext">put :: Word64 -&gt; Put
</span><a href="#local-6989586621679057714"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord64be"><span class="hs-identifier hs-var">putWord64be</span></a></span><span>
</span><span id="line-241"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-242"></span><span>    </span><span id="local-6989586621679057709"><span class="annot"><span class="annottext">putList :: [Word64] -&gt; Put
</span><a href="#local-6989586621679057709"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057708"><span class="annot"><span class="annottext">[Word64]
</span><a href="#local-6989586621679057708"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-243"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word64] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word64]
</span><a href="#local-6989586621679057708"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-244"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word64 -&gt; [Word64] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word64
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word64BE"><span class="hs-identifier hs-var">Prim.word64BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Word64]
</span><a href="#local-6989586621679057708"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-245"></span><span>    </span><span id="local-6989586621679057706"><span class="annot"><span class="annottext">get :: Get Word64
</span><a href="#local-6989586621679057706"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-var">getWord64be</span></a></span><span>
</span><span id="line-246"></span><span>
</span><span id="line-247"></span><span class="hs-comment">-- Int8s are written as a single byte.</span><span>
</span><span id="line-248"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-identifier hs-type">Int8</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-249"></span><span>    </span><span id="local-6989586621679057700"><span class="annot"><span class="annottext">put :: Int8 -&gt; Put
</span><a href="#local-6989586621679057700"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int8 -&gt; Put
</span><a href="Data.Binary.Put.html#putInt8"><span class="hs-identifier hs-var">putInt8</span></a></span><span>
</span><span id="line-250"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-251"></span><span>    </span><span id="local-6989586621679057695"><span class="annot"><span class="annottext">putList :: [Int8] -&gt; Put
</span><a href="#local-6989586621679057695"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057694"><span class="annot"><span class="annottext">[Int8]
</span><a href="#local-6989586621679057694"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-252"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int8] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int8]
</span><a href="#local-6989586621679057694"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-253"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Int8 -&gt; [Int8] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int8
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int8"><span class="hs-identifier hs-var">Prim.int8</span></a></span><span> </span><span class="annot"><span class="annottext">[Int8]
</span><a href="#local-6989586621679057694"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-254"></span><span>    </span><span id="local-6989586621679057692"><span class="annot"><span class="annottext">get :: Get Int8
</span><a href="#local-6989586621679057692"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int8
</span><a href="Data.Binary.Get.html#getInt8"><span class="hs-identifier hs-var">getInt8</span></a></span><span>
</span><span id="line-255"></span><span>
</span><span id="line-256"></span><span class="hs-comment">-- Int16s are written as a 2 bytes in big endian format</span><span>
</span><span id="line-257"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-258"></span><span>    </span><span id="local-6989586621679057686"><span class="annot"><span class="annottext">put :: Int16 -&gt; Put
</span><a href="#local-6989586621679057686"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int16 -&gt; Put
</span><a href="Data.Binary.Put.html#putInt16be"><span class="hs-identifier hs-var">putInt16be</span></a></span><span>
</span><span id="line-259"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-260"></span><span>    </span><span id="local-6989586621679057681"><span class="annot"><span class="annottext">putList :: [Int16] -&gt; Put
</span><a href="#local-6989586621679057681"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057680"><span class="annot"><span class="annottext">[Int16]
</span><a href="#local-6989586621679057680"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-261"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int16] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int16]
</span><a href="#local-6989586621679057680"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-262"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Int16 -&gt; [Int16] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int16
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int16BE"><span class="hs-identifier hs-var">Prim.int16BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Int16]
</span><a href="#local-6989586621679057680"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-263"></span><span>    </span><span id="local-6989586621679057678"><span class="annot"><span class="annottext">get :: Get Int16
</span><a href="#local-6989586621679057678"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int16
</span><a href="Data.Binary.Get.html#getInt16be"><span class="hs-identifier hs-var">getInt16be</span></a></span><span>
</span><span id="line-264"></span><span>
</span><span id="line-265"></span><span class="hs-comment">-- Int32s are written as a 4 bytes in big endian format</span><span>
</span><span id="line-266"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-267"></span><span>    </span><span id="local-6989586621679057672"><span class="annot"><span class="annottext">put :: Int32 -&gt; Put
</span><a href="#local-6989586621679057672"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Put
</span><a href="Data.Binary.Put.html#putInt32be"><span class="hs-identifier hs-var">putInt32be</span></a></span><span>
</span><span id="line-268"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-269"></span><span>    </span><span id="local-6989586621679057667"><span class="annot"><span class="annottext">putList :: [Int32] -&gt; Put
</span><a href="#local-6989586621679057667"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057666"><span class="annot"><span class="annottext">[Int32]
</span><a href="#local-6989586621679057666"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-270"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int32] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int32]
</span><a href="#local-6989586621679057666"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-271"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Int32 -&gt; [Int32] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int32
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int32BE"><span class="hs-identifier hs-var">Prim.int32BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Int32]
</span><a href="#local-6989586621679057666"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-272"></span><span>    </span><span id="local-6989586621679057664"><span class="annot"><span class="annottext">get :: Get Int32
</span><a href="#local-6989586621679057664"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int32
</span><a href="Data.Binary.Get.html#getInt32be"><span class="hs-identifier hs-var">getInt32be</span></a></span><span>
</span><span id="line-273"></span><span>
</span><span id="line-274"></span><span class="hs-comment">-- Int64s are written as a 8 bytes in big endian format</span><span>
</span><span id="line-275"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-276"></span><span>    </span><span id="local-6989586621679057658"><span class="annot"><span class="annottext">put :: Int64 -&gt; Put
</span><a href="#local-6989586621679057658"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Put
</span><a href="Data.Binary.Put.html#putInt64be"><span class="hs-identifier hs-var">putInt64be</span></a></span><span>
</span><span id="line-277"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-278"></span><span>    </span><span id="local-6989586621679057653"><span class="annot"><span class="annottext">putList :: [Int64] -&gt; Put
</span><a href="#local-6989586621679057653"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057652"><span class="annot"><span class="annottext">[Int64]
</span><a href="#local-6989586621679057652"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-279"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int64] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int64]
</span><a href="#local-6989586621679057652"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-280"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Int64 -&gt; [Int64] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int64
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int64BE"><span class="hs-identifier hs-var">Prim.int64BE</span></a></span><span> </span><span class="annot"><span class="annottext">[Int64]
</span><a href="#local-6989586621679057652"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-281"></span><span>    </span><span id="local-6989586621679057650"><span class="annot"><span class="annottext">get :: Get Int64
</span><a href="#local-6989586621679057650"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int64
</span><a href="Data.Binary.Get.html#getInt64be"><span class="hs-identifier hs-var">getInt64be</span></a></span><span>
</span><span id="line-282"></span><span>
</span><span id="line-283"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-284"></span><span>
</span><span id="line-285"></span><span class="hs-comment">-- Words are are written as Word64s, that is, 8 bytes in big endian format</span><span>
</span><span id="line-286"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-287"></span><span>    </span><span id="local-6989586621679057640"><span class="annot"><span class="annottext">put :: Word -&gt; Put
</span><a href="#local-6989586621679057640"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord64be"><span class="hs-identifier hs-var">putWord64be</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Put) -&gt; (Word -&gt; Word64) -&gt; Word -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span>
</span><span id="line-288"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-289"></span><span>    </span><span id="local-6989586621679057634"><span class="annot"><span class="annottext">putList :: [Word] -&gt; Put
</span><a href="#local-6989586621679057634"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057633"><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679057633"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-290"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Word] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679057633"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-291"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word64 -&gt; [Word64] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word64
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word64BE"><span class="hs-identifier hs-var">Prim.word64BE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Word -&gt; Word64) -&gt; [Word] -&gt; [Word64]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Word -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">[Word]
</span><a href="#local-6989586621679057633"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-292"></span><span>    </span><span id="local-6989586621679057627"><span class="annot"><span class="annottext">get :: Get Word
</span><a href="#local-6989586621679057627"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Word) -&gt; Get Word64 -&gt; Get Word
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word64
</span><a href="Data.Binary.Get.html#getWord64be"><span class="hs-identifier hs-var">getWord64be</span></a></span><span>
</span><span id="line-293"></span><span>
</span><span id="line-294"></span><span class="hs-comment">-- Ints are are written as Int64s, that is, 8 bytes in big endian format</span><span>
</span><span id="line-295"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-296"></span><span>    </span><span id="local-6989586621679057619"><span class="annot"><span class="annottext">put :: Int -&gt; Put
</span><a href="#local-6989586621679057619"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Put
</span><a href="Data.Binary.Put.html#putInt64be"><span class="hs-identifier hs-var">putInt64be</span></a></span><span> </span><span class="annot"><span class="annottext">(Int64 -&gt; Put) -&gt; (Int -&gt; Int64) -&gt; Int -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span>
</span><span id="line-297"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#putList"><span class="hs-pragma hs-type">putList</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-298"></span><span>    </span><span id="local-6989586621679057613"><span class="annot"><span class="annottext">putList :: [Int] -&gt; Put
</span><a href="#local-6989586621679057613"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057612"><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679057612"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-299"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679057612"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-300"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Int64 -&gt; [Int64] -&gt; Builder
forall a. FixedPrim a -&gt; [a] -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primMapListFixed"><span class="hs-identifier hs-var">Prim.primMapListFixed</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int64
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int64BE"><span class="hs-identifier hs-var">Prim.int64BE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; Int64) -&gt; [Int] -&gt; [Int64]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679057612"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-301"></span><span>    </span><span id="local-6989586621679057606"><span class="annot"><span class="annottext">get :: Get Int
</span><a href="#local-6989586621679057606"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int64 -&gt; Int) -&gt; Get Int64 -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int64
</span><a href="Data.Binary.Get.html#getInt64be"><span class="hs-identifier hs-var">getInt64be</span></a></span><span>
</span><span id="line-302"></span><span>
</span><span id="line-303"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-304"></span><span class="hs-comment">--</span><span>
</span><span id="line-305"></span><span class="hs-comment">-- Portable, and pretty efficient, serialisation of Integer</span><span>
</span><span id="line-306"></span><span class="hs-comment">--</span><span>
</span><span id="line-307"></span><span>
</span><span id="line-308"></span><span class="hs-comment">-- Fixed-size type for a subset of Integer</span><span>
</span><span id="line-309"></span><span class="hs-keyword">type</span><span> </span><span id="SmallInt"><span class="annot"><a href="Data.Binary.Class.html#SmallInt"><span class="hs-identifier hs-var">SmallInt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span>
</span><span id="line-310"></span><span>
</span><span id="line-311"></span><span class="hs-comment">-- Integers are encoded in two ways: if they fit inside a SmallInt,</span><span>
</span><span id="line-312"></span><span class="hs-comment">-- they're written as a byte tag, and that value.  If the Integer value</span><span>
</span><span id="line-313"></span><span class="hs-comment">-- is too large to fit in a SmallInt, it is written as a byte array,</span><span>
</span><span id="line-314"></span><span class="hs-comment">-- along with a sign and length field.</span><span>
</span><span id="line-315"></span><span>
</span><span id="line-316"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057601"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-317"></span><span>
</span><span id="line-318"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-319"></span><span>    </span><span id="local-6989586621679057577"><span class="annot"><span class="annottext">put :: Integer -&gt; Put
</span><a href="#local-6989586621679057577"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679057576"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057576"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057576"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057575"><span class="hs-identifier hs-var">lo</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057576"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057572"><span class="hs-identifier hs-var">hi</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-320"></span><span>        </span><span class="annot"><span class="annottext">Builder -&gt; Put
</span><a href="Data.Binary.Put.html#putBuilder"><span class="hs-identifier hs-var">putBuilder</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim (Word8, Int32) -&gt; (Word8, Int32) -&gt; Builder
forall a. FixedPrim a -&gt; a -&gt; Builder
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.html#primFixed"><span class="hs-identifier hs-var">Prim.primFixed</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FixedPrim Word8
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#word8"><span class="hs-identifier hs-var">Prim.word8</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Word8 -&gt; FixedPrim Int32 -&gt; FixedPrim (Word8, Int32)
forall (f :: * -&gt; *) a b. Monoidal f =&gt; f a -&gt; f b -&gt; f (a, b)
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Internal.html#%3E%2A%3C"><span class="hs-operator hs-var">Prim.&gt;*&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">FixedPrim Int32
</span><a href="../../bytestring/src/Data.ByteString.Builder.Prim.Binary.html#int32BE"><span class="hs-identifier hs-var">Prim.int32BE</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057576"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-321"></span><span>     </span><span class="hs-keyword">where</span><span>
</span><span id="line-322"></span><span>        </span><span id="local-6989586621679057575"><span class="annot"><span class="annottext">lo :: Integer
</span><a href="#local-6989586621679057575"><span class="hs-identifier hs-var hs-var">lo</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#minBound"><span class="hs-identifier hs-var">minBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#SmallInt"><span class="hs-identifier hs-type">SmallInt</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-323"></span><span>        </span><span id="local-6989586621679057572"><span class="annot"><span class="annottext">hi :: Integer
</span><a href="#local-6989586621679057572"><span class="hs-identifier hs-var hs-var">hi</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#SmallInt"><span class="hs-identifier hs-type">SmallInt</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-324"></span><span>
</span><span id="line-325"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span id="local-6989586621679057559"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057559"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-326"></span><span>        </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-327"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057558"><span class="hs-identifier hs-var">sign</span></a></span><span>
</span><span id="line-328"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; [Word8]
forall a. (Integral a, Bits a) =&gt; a -&gt; [Word8]
</span><a href="Data.Binary.Class.html#unroll"><span class="hs-identifier hs-var">unroll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#abs"><span class="hs-identifier hs-var">abs</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057559"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>         </span><span class="hs-comment">-- unroll the bytes</span><span>
</span><span id="line-329"></span><span>     </span><span class="hs-keyword">where</span><span>
</span><span id="line-330"></span><span>        </span><span id="local-6989586621679057558"><span class="annot"><span class="annottext">sign :: Word8
</span><a href="#local-6989586621679057558"><span class="hs-identifier hs-var hs-var">sign</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#signum"><span class="hs-identifier hs-var">signum</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057559"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-331"></span><span>
</span><span id="line-332"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-333"></span><span>    </span><span id="local-6989586621679057536"><span class="annot"><span class="annottext">get :: Get Integer
</span><a href="#local-6989586621679057536"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-334"></span><span>        </span><span id="local-6989586621679057535"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057535"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-335"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057535"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-336"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(Int32 -&gt; Integer) -&gt; Get Int32 -&gt; Get Integer
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Get Int32
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="Data.Binary.Class.html#SmallInt"><span class="hs-identifier hs-type">SmallInt</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-337"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679057534"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057534"><span class="hs-identifier hs-var">sign</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-338"></span><span>                    </span><span id="local-6989586621679057533"><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057533"><span class="hs-identifier hs-var">bytes</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get [Word8]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-339"></span><span>                    </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679057532"><span class="annot"><span class="annottext">v :: Integer
</span><a href="#local-6989586621679057532"><span class="hs-identifier hs-var hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Integer
forall a. (Integral a, Bits a) =&gt; [Word8] -&gt; a
</span><a href="Data.Binary.Class.html#roll"><span class="hs-identifier hs-var">roll</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057533"><span class="hs-identifier hs-var">bytes</span></a></span><span>
</span><span id="line-340"></span><span>                    </span><span class="annot"><span class="annottext">Integer -&gt; Get Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Get Integer) -&gt; Integer -&gt; Get Integer
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057534"><span class="hs-identifier hs-var">sign</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word8 -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057532"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="hs-glyph">-</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057532"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-341"></span><span>
</span><span id="line-342"></span><span class="hs-comment">-- | @since 0.8.0.0</span><span class="hs-cpp">
#ifdef HAS_FIXED_CONSTRUCTOR
</span><span id="local-6989586621679058409"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057526"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Fixed.html#Fixed"><span class="hs-identifier hs-type">Fixed.Fixed</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058409"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-345"></span><span>  </span><span id="local-6989586621679057524"><span class="annot"><span class="annottext">put :: Fixed a -&gt; Put
</span><a href="#local-6989586621679057524"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Fixed.html#MkFixed"><span class="hs-identifier hs-type">Fixed.MkFixed</span></a></span><span> </span><span id="local-6989586621679057522"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057522"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679057522"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-346"></span><span>  </span><span id="local-6989586621679057519"><span class="annot"><span class="annottext">get :: Get (Fixed a)
</span><a href="#local-6989586621679057519"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Fixed a
forall k (a :: k). Integer -&gt; Fixed a
</span><a href="../../base/src/Data.Fixed.html#MkFixed"><span class="hs-identifier hs-var">Fixed.MkFixed</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Fixed a) -&gt; Get Integer -&gt; Get (Fixed a)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-operator hs-var">`liftM`</span></a></span><span> </span><span class="annot"><span class="annottext">Get Integer
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span class="hs-cpp">
#else
</span><span class="hs-keyword">instance</span><span> </span><span class="hs-keyword">forall</span><span> </span><span class="hs-identifier">a</span><span class="hs-operator">.</span><span> </span><span class="hs-identifier">Fixed.HasResolution</span><span> </span><span class="hs-identifier">a</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-identifier">Binary</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">Fixed.Fixed</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-349"></span><span>  </span><span class="hs-comment">-- Using undefined :: Maybe a as a proxy, as Data.Proxy is introduced only in base-4.7</span><span>
</span><span id="line-350"></span><span>  </span><span class="hs-identifier">put</span><span> </span><span class="hs-identifier">x</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">put</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">truncate</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">x</span><span> </span><span class="hs-operator">*</span><span> </span><span class="hs-identifier">fromInteger</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">Fixed.resolution</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">undefined</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-identifier">Maybe</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-identifier">Integer</span><span class="hs-special">)</span><span>
</span><span id="line-351"></span><span>  </span><span class="hs-identifier">get</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-identifier">x</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-identifier">fromInteger</span><span> </span><span class="hs-identifier">x</span><span> </span><span class="hs-operator">/</span><span> </span><span class="hs-identifier">fromInteger</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">Fixed.resolution</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">undefined</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-identifier">Maybe</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">`</span><span class="hs-identifier">liftM</span><span class="hs-special">`</span><span> </span><span class="hs-identifier">get</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-354"></span><span class="hs-comment">--</span><span>
</span><span id="line-355"></span><span class="hs-comment">-- Fold and unfold an Integer to and from a list of its bytes</span><span>
</span><span id="line-356"></span><span class="hs-comment">--</span><span>
</span><span id="line-357"></span><span id="local-6989586621679058417"><span class="annot"><a href="Data.Binary.Class.html#unroll"><span class="hs-identifier hs-type">unroll</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058417"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#Bits"><span class="hs-identifier hs-type">Bits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058417"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679058417"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-358"></span><span id="unroll"><span class="annot"><span class="annottext">unroll :: forall a. (Integral a, Bits a) =&gt; a -&gt; [Word8]
</span><a href="Data.Binary.Class.html#unroll"><span class="hs-identifier hs-var hs-var">unroll</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Maybe (Word8, a)) -&gt; a -&gt; [Word8]
forall b a. (b -&gt; Maybe (a, b)) -&gt; b -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#unfoldr"><span class="hs-identifier hs-var">unfoldr</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe (Word8, a)
forall {b} {a}. (Integral b, Num a, Bits b) =&gt; b -&gt; Maybe (a, b)
</span><a href="#local-6989586621679057513"><span class="hs-identifier hs-var">step</span></a></span><span>
</span><span id="line-359"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-360"></span><span>    </span><span id="local-6989586621679057513"><span class="annot"><span class="annottext">step :: b -&gt; Maybe (a, b)
</span><a href="#local-6989586621679057513"><span class="hs-identifier hs-var hs-var">step</span></a></span></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (a, b)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-361"></span><span>    </span><span class="annot"><a href="#local-6989586621679057513"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span id="local-6989586621679057496"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057496"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, b) -&gt; Maybe (a, b)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057496"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057496"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Int -&gt; b
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span>
</span><span id="line-362"></span><span>
</span><span id="line-363"></span><span id="local-6989586621679058415"><span class="annot"><a href="Data.Binary.Class.html#roll"><span class="hs-identifier hs-type">roll</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058415"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#Bits"><span class="hs-identifier hs-type">Bits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058415"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679058415"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-364"></span><span id="roll"><span class="annot"><span class="annottext">roll :: forall a. (Integral a, Bits a) =&gt; [Word8] -&gt; a
</span><a href="Data.Binary.Class.html#roll"><span class="hs-identifier hs-var hs-var">roll</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Word8 -&gt; a) -&gt; a -&gt; [Word8] -&gt; a
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Word8 -&gt; a
forall {a} {a}. (Bits a, Integral a, Num a) =&gt; a -&gt; a -&gt; a
</span><a href="#local-6989586621679057484"><span class="hs-identifier hs-var">unstep</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">([Word8] -&gt; a) -&gt; ([Word8] -&gt; [Word8]) -&gt; [Word8] -&gt; a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; [Word8]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#reverse"><span class="hs-identifier hs-var">reverse</span></a></span><span>
</span><span id="line-365"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-366"></span><span>    </span><span id="local-6989586621679057484"><span class="annot"><span class="annottext">unstep :: a -&gt; a -&gt; a
</span><a href="#local-6989586621679057484"><span class="hs-identifier hs-var hs-var">unstep</span></a></span></span><span> </span><span id="local-6989586621679057475"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057475"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679057474"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057474"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057475"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057474"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-cpp">

#ifdef HAS_NATURAL
</span><span class="hs-comment">-- Fixed-size type for a subset of Natural</span><span>
</span><span id="line-370"></span><span class="hs-keyword">type</span><span> </span><span id="NaturalWord"><span class="annot"><a href="Data.Binary.Class.html#NaturalWord"><span class="hs-identifier hs-var">NaturalWord</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-371"></span><span>
</span><span id="line-372"></span><span class="hs-comment">-- | @since 0.7.3.0</span><span>
</span><span id="line-373"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057467"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Natural</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-374"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-375"></span><span>    </span><span id="local-6989586621679057450"><span class="annot"><span class="annottext">put :: Natural -&gt; Put
</span><a href="#local-6989586621679057450"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679057449"><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057449"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057449"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Natural -&gt; Natural -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057448"><span class="hs-identifier hs-var">hi</span></a></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-376"></span><span>        </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-377"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Natural -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057449"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#NaturalWord"><span class="hs-identifier hs-type">NaturalWord</span></a></span><span class="hs-special">)</span><span>  </span><span class="hs-comment">-- fast path</span><span>
</span><span id="line-378"></span><span>     </span><span class="hs-keyword">where</span><span>
</span><span id="line-379"></span><span>        </span><span id="local-6989586621679057448"><span class="annot"><span class="annottext">hi :: Natural
</span><a href="#local-6989586621679057448"><span class="hs-identifier hs-var hs-var">hi</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Natural
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#NaturalWord"><span class="hs-identifier hs-type">NaturalWord</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Natural</span></span><span>
</span><span id="line-380"></span><span>
</span><span id="line-381"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span id="local-6989586621679057443"><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057443"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-382"></span><span>        </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-383"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Natural -&gt; [Word8]
forall a. (Integral a, Bits a) =&gt; a -&gt; [Word8]
</span><a href="Data.Binary.Class.html#unroll"><span class="hs-identifier hs-var">unroll</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Natural -&gt; Natural
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#abs"><span class="hs-identifier hs-var">abs</span></a></span><span> </span><span class="annot"><span class="annottext">Natural
</span><a href="#local-6989586621679057443"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>         </span><span class="hs-comment">-- unroll the bytes</span><span>
</span><span id="line-384"></span><span>
</span><span id="line-385"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-386"></span><span>    </span><span id="local-6989586621679057429"><span class="annot"><span class="annottext">get :: Get Natural
</span><a href="#local-6989586621679057429"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-387"></span><span>        </span><span id="local-6989586621679057428"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057428"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-388"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057428"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-389"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; Natural) -&gt; Get Word64 -&gt; Get Natural
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Natural
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Get Word64
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="Data.Binary.Class.html#NaturalWord"><span class="hs-identifier hs-type">NaturalWord</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-390"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679057427"><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057427"><span class="hs-identifier hs-var">bytes</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get [Word8]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-391"></span><span>                    </span><span class="annot"><span class="annottext">Natural -&gt; Get Natural
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Natural -&gt; Get Natural) -&gt; Natural -&gt; Get Natural
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Natural
forall a. (Integral a, Bits a) =&gt; [Word8] -&gt; a
</span><a href="Data.Binary.Class.html#roll"><span class="hs-identifier hs-var">roll</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621679057427"><span class="hs-identifier hs-var">bytes</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-394"></span><span class="hs-comment">{-

--
-- An efficient, raw serialisation for Integer (GHC only)
--

-- TODO  This instance is not architecture portable.  GMP stores numbers as
-- arrays of machine sized words, so the byte format is not portable across
-- architectures with different endianness and word size.

import Data.ByteString.Base (toForeignPtr,unsafePackAddress, memcpy)
import GHC.Base     hiding (ord, chr)
import GHC.Prim
import GHC.Ptr (Ptr(..))
import GHC.IOBase (IO(..))

instance Binary Integer where
    put (S# i)    = putWord8 0 &gt;&gt; put (I# i)
    put (J# s ba) = do
        putWord8 1
        put (I# s)
        put (BA ba)

    get = do
        b &lt;- getWord8
        case b of
            0 -&gt; do (I# i#) &lt;- get
                    return (S# i#)
            _ -&gt; do (I# s#) &lt;- get
                    (BA a#) &lt;- get
                    return (J# s# a#)

instance Binary ByteArray where

    -- Pretty safe.
    put (BA ba) =
        let sz   = sizeofByteArray# ba   -- (primitive) in *bytes*
            addr = byteArrayContents# ba
            bs   = unsafePackAddress (I# sz) addr
        in put bs   -- write as a ByteString. easy, yay!

    -- Pretty scary. Should be quick though
    get = do
        (fp, off, n@(I# sz)) &lt;- liftM toForeignPtr get      -- so decode a ByteString
        assert (off == 0) $ return $ unsafePerformIO $ do
            (MBA arr) &lt;- newByteArray sz                    -- and copy it into a ByteArray#
            let to = byteArrayContents# (unsafeCoerce# arr) -- urk, is this safe?
            withForeignPtr fp $ \from -&gt; memcpy (Ptr to) from (fromIntegral n)
            freezeByteArray arr

-- wrapper for ByteArray#
data ByteArray = BA  {-# UNPACK #-} !ByteArray#
data MBA       = MBA {-# UNPACK #-} !(MutableByteArray# RealWorld)

newByteArray :: Int# -&gt; IO MBA
newByteArray sz = IO $ \s -&gt;
  case newPinnedByteArray# sz s of { (# s', arr #) -&gt;
  (# s', MBA arr #) }

freezeByteArray :: MutableByteArray# RealWorld -&gt; IO ByteArray
freezeByteArray arr = IO $ \s -&gt;
  case unsafeFreezeByteArray# arr s of { (# s', arr' #) -&gt;
  (# s', BA arr' #) }

-}</span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span id="local-6989586621679058391"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057423"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058391"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058391"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Ratio"><span class="hs-identifier hs-type">R.Ratio</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058391"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-461"></span><span>    </span><span id="local-6989586621679057419"><span class="annot"><span class="annottext">put :: Ratio a -&gt; Put
</span><a href="#local-6989586621679057419"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679057418"><span class="annot"><span class="annottext">Ratio a
</span><a href="#local-6989586621679057418"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ratio a -&gt; a
forall a. Ratio a -&gt; a
</span><a href="../../base/src/GHC.Real.html#numerator"><span class="hs-identifier hs-var">R.numerator</span></a></span><span> </span><span class="annot"><span class="annottext">Ratio a
</span><a href="#local-6989586621679057418"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ratio a -&gt; a
forall a. Ratio a -&gt; a
</span><a href="../../base/src/GHC.Real.html#denominator"><span class="hs-identifier hs-var">R.denominator</span></a></span><span> </span><span class="annot"><span class="annottext">Ratio a
</span><a href="#local-6989586621679057418"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-462"></span><span>    </span><span id="local-6989586621679057411"><span class="annot"><span class="annottext">get :: Get (Ratio a)
</span><a href="#local-6989586621679057411"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; a -&gt; Ratio a) -&gt; Get a -&gt; Get a -&gt; Get (Ratio a)
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ratio a
forall a. Integral a =&gt; a -&gt; a -&gt; Ratio a
</span><a href="../../base/src/GHC.Real.html#%25"><span class="hs-operator hs-var">(R.%)</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-463"></span><span>
</span><span id="line-464"></span><span id="local-6989586621679058384"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057405"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058384"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Complex.html#Complex"><span class="hs-identifier hs-type">Complex</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058384"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-465"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-466"></span><span>    </span><span id="local-6989586621679057403"><span class="annot"><span class="annottext">put :: Complex a -&gt; Put
</span><a href="#local-6989586621679057403"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057402"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057402"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/Data.Complex.html#%3A%2B"><span class="hs-operator hs-type">:+</span></a></span><span> </span><span id="local-6989586621679057400"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057400"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, a) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057402"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057400"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-467"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-468"></span><span>    </span><span id="local-6989586621679057397"><span class="annot"><span class="annottext">get :: Get (Complex a)
</span><a href="#local-6989586621679057397"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679057396"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057396"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057395"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057395"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057396"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Complex a
forall a. a -&gt; a -&gt; Complex a
</span><a href="../../base/src/Data.Complex.html#%3A%2B"><span class="hs-operator hs-var">:+</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057395"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((a, a) -&gt; Complex a) -&gt; Get (a, a) -&gt; Get (Complex a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get (a, a)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-469"></span><span>
</span><span id="line-470"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-471"></span><span>
</span><span id="line-472"></span><span class="hs-comment">-- Char is serialised as UTF-8</span><span>
</span><span id="line-473"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-474"></span><span>    </span><span id="local-6989586621679057389"><span class="annot"><span class="annottext">put :: Char -&gt; Put
</span><a href="#local-6989586621679057389"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Put
</span><a href="Data.Binary.Put.html#putCharUtf8"><span class="hs-identifier hs-var">putCharUtf8</span></a></span><span>
</span><span id="line-475"></span><span>    </span><span id="local-6989586621679057384"><span class="annot"><span class="annottext">putList :: String -&gt; Put
</span><a href="#local-6989586621679057384"><span class="hs-identifier hs-var hs-var hs-var hs-var">putList</span></a></span></span><span> </span><span id="local-6989586621679057383"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679057383"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679057383"><span class="hs-identifier hs-var">str</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Put
</span><a href="Data.Binary.Put.html#putStringUtf8"><span class="hs-identifier hs-var">putStringUtf8</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679057383"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-476"></span><span>    </span><span id="local-6989586621679057324"><span class="annot"><span class="annottext">get :: Get Char
</span><a href="#local-6989586621679057324"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-477"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679057319"><span class="annot"><span class="annottext">getByte :: Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var hs-var">getByte</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Int) -&gt; Get Word8 -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Word8
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-478"></span><span>            </span><span id="local-6989586621679057316"><span class="annot"><span class="annottext">shiftL6 :: Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var hs-var">shiftL6</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int -&gt; Int) -&gt; Int -&gt; Int -&gt; Int
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-identifier hs-var">shiftL</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-479"></span><span>        </span><span id="local-6989586621679057314"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-480"></span><span>        </span><span id="local-6989586621679057313"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057313"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-481"></span><span>                </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-482"></span><span>                  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0xe0</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-483"></span><span>                                    </span><span id="local-6989586621679057311"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057311"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-484"></span><span>                                    </span><span class="annot"><span class="annottext">Int -&gt; Get Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057311"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0xc0</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-485"></span><span>                  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0xf0</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-486"></span><span>                                    </span><span id="local-6989586621679057309"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057309"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-487"></span><span>                                    </span><span id="local-6989586621679057308"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057308"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-488"></span><span>                                    </span><span class="annot"><span class="annottext">Int -&gt; Get Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057308"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057309"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span>
</span><span id="line-489"></span><span>                                            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0xe0</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-490"></span><span>                  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-491"></span><span>                                </span><span id="local-6989586621679057307"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057307"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-492"></span><span>                                </span><span id="local-6989586621679057306"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057306"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-493"></span><span>                                </span><span id="local-6989586621679057305"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057305"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Int) -&gt; Get Int -&gt; Get Int
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0x80</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get Int
</span><a href="#local-6989586621679057319"><span class="hs-identifier hs-var">getByte</span></a></span><span>
</span><span id="line-494"></span><span>                                </span><span class="annot"><span class="annottext">Int -&gt; Get Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057305"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057306"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span>
</span><span id="line-495"></span><span>                                        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057307"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621679057316"><span class="hs-identifier hs-var">shiftL6</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#xor"><span class="hs-identifier hs-var">xor</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0xf0</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057314"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-496"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Get Char
forall {a} {m :: * -&gt; *} {a}.
(Ord a, Num a, Enum a, Enum a, MonadFail m) =&gt;
a -&gt; m a
</span><a href="#local-6989586621679057304"><span class="hs-identifier hs-var">getChr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057313"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-497"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-498"></span><span>        </span><span id="local-6989586621679057304"><span class="annot"><span class="annottext">getChr :: a -&gt; m a
</span><a href="#local-6989586621679057304"><span class="hs-identifier hs-var hs-var">getChr</span></a></span></span><span> </span><span id="local-6989586621679057291"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057291"><span class="hs-identifier hs-var">w</span></a></span></span><span>
</span><span id="line-499"></span><span>          </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057291"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0x10ffff</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; m a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; m a) -&gt; a -&gt; m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; a
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; a) -&gt; Int -&gt; a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057291"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-500"></span><span>          </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Not a valid Unicode code point!&quot;</span></span><span>
</span><span id="line-501"></span><span>
</span><span id="line-502"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-503"></span><span class="hs-comment">-- Instances for the first few tuples</span><span>
</span><span id="line-504"></span><span>
</span><span id="line-505"></span><span id="local-6989586621679058382"><span id="local-6989586621679058383"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057286"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058383"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058382"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058383"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058382"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-506"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-507"></span><span>    </span><span id="local-6989586621679057282"><span class="annot"><span class="annottext">put :: (a, b) -&gt; Put
</span><a href="#local-6989586621679057282"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057281"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057281"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057280"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057280"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057281"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057280"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-508"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-509"></span><span>    </span><span id="local-6989586621679057276"><span class="annot"><span class="annottext">get :: Get (a, b)
</span><a href="#local-6989586621679057276"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; (a, b)) -&gt; Get a -&gt; Get b -&gt; Get (a, b)
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span><span>
</span><span id="line-510"></span><span>
</span><span id="line-511"></span><span id="local-6989586621679058368"><span id="local-6989586621679058369"><span id="local-6989586621679058370"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057272"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058370"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058369"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058368"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058370"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058369"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058368"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-512"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-513"></span><span>    </span><span id="local-6989586621679057266"><span class="annot"><span class="annottext">put :: (a, b, c) -&gt; Put
</span><a href="#local-6989586621679057266"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057265"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057265"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057264"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057264"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057263"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057263"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">)</span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057265"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057264"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057263"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-514"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-515"></span><span>    </span><span id="local-6989586621679057258"><span class="annot"><span class="annottext">get :: Get (a, b, c)
</span><a href="#local-6989586621679057258"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; c -&gt; (a, b, c))
-&gt; Get a -&gt; Get b -&gt; Get c -&gt; Get (a, b, c)
forall (m :: * -&gt; *) a1 a2 a3 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; a3 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m a3 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM3"><span class="hs-identifier hs-var">liftM3</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get c
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span></span><span>
</span><span id="line-516"></span><span>
</span><span id="line-517"></span><span id="local-6989586621679058358"><span id="local-6989586621679058359"><span id="local-6989586621679058360"><span id="local-6989586621679058361"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057253"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058361"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058360"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058359"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058358"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058361"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058360"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058359"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058358"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-518"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-519"></span><span>    </span><span id="local-6989586621679057245"><span class="annot"><span class="annottext">put :: (a, b, c, d) -&gt; Put
</span><a href="#local-6989586621679057245"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057244"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057244"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057243"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057243"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057242"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057242"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057241"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057241"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057244"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057243"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057242"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">d -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057241"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-520"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-521"></span><span>    </span><span id="local-6989586621679057235"><span class="annot"><span class="annottext">get :: Get (a, b, c, d)
</span><a href="#local-6989586621679057235"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; c -&gt; d -&gt; (a, b, c, d))
-&gt; Get a -&gt; Get b -&gt; Get c -&gt; Get d -&gt; Get (a, b, c, d)
forall (m :: * -&gt; *) a1 a2 a3 a4 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; a3 -&gt; a4 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m a3 -&gt; m a4 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM4"><span class="hs-identifier hs-var">liftM4</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get c
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get d
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span></span></span><span>
</span><span id="line-522"></span><span>
</span><span id="line-523"></span><span id="local-6989586621679058346"><span id="local-6989586621679058347"><span id="local-6989586621679058348"><span id="local-6989586621679058349"><span id="local-6989586621679058350"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057230"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058350"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058349"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058348"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058347"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058346"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058350"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058349"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058348"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058347"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058346"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-524"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-525"></span><span>    </span><span id="local-6989586621679057220"><span class="annot"><span class="annottext">put :: (a, b, c, d, e) -&gt; Put
</span><a href="#local-6989586621679057220"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057219"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057219"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057218"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057218"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057217"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057217"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057216"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057216"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057215"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057215"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">)</span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057219"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057218"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057217"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">d -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057216"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057215"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-526"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-527"></span><span>    </span><span id="local-6989586621679057208"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e)
</span><a href="#local-6989586621679057208"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; c -&gt; d -&gt; e -&gt; (a, b, c, d, e))
-&gt; Get a -&gt; Get b -&gt; Get c -&gt; Get d -&gt; Get e -&gt; Get (a, b, c, d, e)
forall (m :: * -&gt; *) a1 a2 a3 a4 a5 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; a3 -&gt; a4 -&gt; a5 -&gt; r)
-&gt; m a1 -&gt; m a2 -&gt; m a3 -&gt; m a4 -&gt; m a5 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM5"><span class="hs-identifier hs-var">liftM5</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get c
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get d
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get e
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span></span></span></span><span>
</span><span id="line-528"></span><span>
</span><span id="line-529"></span><span class="hs-comment">--</span><span>
</span><span id="line-530"></span><span class="hs-comment">-- and now just recurse:</span><span>
</span><span id="line-531"></span><span class="hs-comment">--</span><span>
</span><span id="line-532"></span><span>
</span><span id="line-533"></span><span id="local-6989586621679058332"><span id="local-6989586621679058333"><span id="local-6989586621679058334"><span id="local-6989586621679058335"><span id="local-6989586621679058336"><span id="local-6989586621679058337"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057203"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058337"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058336"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058335"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058334"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058333"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058332"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-534"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058337"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058336"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058335"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058334"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058333"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058332"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-535"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-536"></span><span>    </span><span id="local-6989586621679057200"><span class="annot"><span class="annottext">put :: (a, b, c, d, e, f) -&gt; Put
</span><a href="#local-6989586621679057200"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057199"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057199"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057198"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057198"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057197"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057197"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057196"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057196"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057195"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057195"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057194"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057194"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">)</span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, (b, c, d, e, f)) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057199"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057198"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057197"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057196"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057195"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057194"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-537"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-538"></span><span>    </span><span id="local-6989586621679057189"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e, f)
</span><a href="#local-6989586621679057189"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057188"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057188"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="hs-special">(</span><span id="local-6989586621679057187"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057187"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057186"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057186"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057185"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057185"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057184"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057184"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057183"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057183"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (a, (b, c, d, e, f))
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f) -&gt; Get (a, b, c, d, e, f)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057188"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057187"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057186"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057185"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057184"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057183"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span><span>
</span><span id="line-539"></span><span>
</span><span id="line-540"></span><span id="local-6989586621679058325"><span id="local-6989586621679058326"><span id="local-6989586621679058327"><span id="local-6989586621679058328"><span id="local-6989586621679058329"><span id="local-6989586621679058330"><span id="local-6989586621679058331"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057179"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058331"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058330"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058329"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058328"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058327"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058326"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058325"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-541"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058331"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058330"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058329"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058328"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058327"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058326"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058325"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-542"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-543"></span><span>    </span><span id="local-6989586621679057176"><span class="annot"><span class="annottext">put :: (a, b, c, d, e, f, g) -&gt; Put
</span><a href="#local-6989586621679057176"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057175"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057175"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057174"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057174"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057173"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057173"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057172"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057172"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057171"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057171"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057170"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057170"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057169"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057169"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, (b, c, d, e, f, g)) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057175"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057174"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057173"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057172"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057171"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057170"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057169"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-544"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-545"></span><span>    </span><span id="local-6989586621679057164"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e, f, g)
</span><a href="#local-6989586621679057164"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                 </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057163"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057163"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="hs-special">(</span><span id="local-6989586621679057162"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057162"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057161"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057161"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057160"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057160"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057159"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057159"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057158"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057158"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057157"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057157"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (a, (b, c, d, e, f, g))
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g) -&gt; Get (a, b, c, d, e, f, g)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057163"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057162"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057161"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057160"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057159"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057158"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057157"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span><span>
</span><span id="line-546"></span><span>
</span><span id="line-547"></span><span id="local-6989586621679058317"><span id="local-6989586621679058318"><span id="local-6989586621679058319"><span id="local-6989586621679058320"><span id="local-6989586621679058321"><span id="local-6989586621679058322"><span id="local-6989586621679058323"><span id="local-6989586621679058324"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057153"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058324"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058323"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058322"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058321"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058320"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-548"></span><span>          </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058319"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058318"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058317"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-549"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058324"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058323"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058322"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058321"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058320"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058319"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058318"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058317"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-550"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-551"></span><span>    </span><span id="local-6989586621679057150"><span class="annot"><span class="annottext">put :: (a, b, c, d, e, f, g, h) -&gt; Put
</span><a href="#local-6989586621679057150"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057149"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057149"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057148"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057148"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057147"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057147"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057146"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057146"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057145"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057145"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057144"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057144"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057143"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057143"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057142"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057142"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, (b, c, d, e, f, g, h)) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057149"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057148"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057147"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057146"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057145"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057144"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057143"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057142"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-552"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-553"></span><span>    </span><span id="local-6989586621679057137"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e, f, g, h)
</span><a href="#local-6989586621679057137"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                   </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057136"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057136"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="hs-special">(</span><span id="local-6989586621679057135"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057135"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057134"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057134"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057133"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057133"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057132"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057132"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057131"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057131"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057130"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057130"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057129"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057129"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (a, (b, c, d, e, f, g, h))
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h) -&gt; Get (a, b, c, d, e, f, g, h)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057136"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057135"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057134"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057133"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057132"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057131"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057130"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057129"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span></span><span>
</span><span id="line-554"></span><span>
</span><span id="line-555"></span><span id="local-6989586621679058308"><span id="local-6989586621679058309"><span id="local-6989586621679058310"><span id="local-6989586621679058311"><span id="local-6989586621679058312"><span id="local-6989586621679058313"><span id="local-6989586621679058314"><span id="local-6989586621679058315"><span id="local-6989586621679058316"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057125"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058316"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058315"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058314"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058313"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058312"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-556"></span><span>          </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058311"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058310"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058309"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058308"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-557"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058316"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058315"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058314"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058313"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058312"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058311"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058310"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058309"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058308"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-558"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-559"></span><span>    </span><span id="local-6989586621679057122"><span class="annot"><span class="annottext">put :: (a, b, c, d, e, f, g, h, i) -&gt; Put
</span><a href="#local-6989586621679057122"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057121"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057121"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057120"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057120"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057119"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057119"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057118"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057118"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057117"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057117"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057116"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057116"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057115"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057115"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057114"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057114"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057113"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057113"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, (b, c, d, e, f, g, h, i)) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057121"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057120"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057119"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057118"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057117"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057116"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057115"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057114"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057113"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-560"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-561"></span><span>    </span><span id="local-6989586621679057108"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e, f, g, h, i)
</span><a href="#local-6989586621679057108"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                     </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057107"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057107"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="hs-special">(</span><span id="local-6989586621679057106"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057106"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057105"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057105"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057104"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057104"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057103"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057103"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057102"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057102"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057101"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057101"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057100"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057100"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057099"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057099"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (a, (b, c, d, e, f, g, h, i))
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i) -&gt; Get (a, b, c, d, e, f, g, h, i)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057107"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057106"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057105"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057104"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057103"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057102"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057101"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057100"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057099"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-562"></span><span>
</span><span id="line-563"></span><span id="local-6989586621679058298"><span id="local-6989586621679058299"><span id="local-6989586621679058300"><span id="local-6989586621679058301"><span id="local-6989586621679058302"><span id="local-6989586621679058303"><span id="local-6989586621679058304"><span id="local-6989586621679058305"><span id="local-6989586621679058306"><span id="local-6989586621679058307"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057095"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058307"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058306"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058305"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058304"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058303"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-564"></span><span>          </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058302"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058301"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058300"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058299"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058298"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-565"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058307"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058306"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058305"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058304"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058303"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058302"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058301"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058300"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058299"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679058298"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-566"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-pragma hs-type">put</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-567"></span><span>    </span><span id="local-6989586621679057092"><span class="annot"><span class="annottext">put :: (a, b, c, d, e, f, g, h, i, j) -&gt; Put
</span><a href="#local-6989586621679057092"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057091"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057091"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057090"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057090"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057089"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057089"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057088"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057088"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057087"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057087"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057086"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057086"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057085"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057085"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057084"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057084"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057083"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057083"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057082"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679057082"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, (b, c, d, e, f, g, h, i, j)) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057091"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="hs-special">(</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057090"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057089"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057088"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057087"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057086"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057085"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057084"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057083"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679057082"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-568"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#get"><span class="hs-pragma hs-type">get</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-569"></span><span>    </span><span id="local-6989586621679057077"><span class="annot"><span class="annottext">get :: Get (a, b, c, d, e, f, g, h, i, j)
</span><a href="#local-6989586621679057077"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                       </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679057076"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057076"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="hs-special">(</span><span id="local-6989586621679057075"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057075"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057074"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057074"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057073"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057073"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057072"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057072"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057071"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057071"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057070"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057070"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057069"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057069"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057068"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057068"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679057067"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679057067"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (a, (b, c, d, e, f, g, h, i, j))
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j)
-&gt; Get (a, b, c, d, e, f, g, h, i, j)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057076"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679057075"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679057074"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679057073"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679057072"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679057071"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679057070"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679057069"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679057068"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679057067"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-570"></span><span>
</span><span id="line-571"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-572"></span><span class="hs-comment">-- Container types</span><span class="hs-cpp">

#if MIN_VERSION_base(4,8,0)
</span><span id="local-6989586621679058297"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057063"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058297"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058297"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-576"></span><span>  </span><span id="local-6989586621679057061"><span class="annot"><span class="annottext">put :: Identity a -&gt; Put
</span><a href="#local-6989586621679057061"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span id="local-6989586621679057059"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057059"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057059"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-577"></span><span>  </span><span id="local-6989586621679057056"><span class="annot"><span class="annottext">get :: Get (Identity a)
</span><a href="#local-6989586621679057056"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Identity a
forall a. a -&gt; Identity a
</span><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-var">Identity</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Identity a) -&gt; Get a -&gt; Get (Identity a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-580"></span><span id="local-6989586621679058483"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057052"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058483"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679058483"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-581"></span><span>    </span><span id="local-6989586621679057050"><span class="annot"><span class="annottext">put :: [a] -&gt; Put
</span><a href="#local-6989586621679057050"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Put
forall a. Binary a =&gt; [a] -&gt; Put
</span><a href="Data.Binary.Class.html#putList"><span class="hs-identifier hs-var">putList</span></a></span><span>
</span><span id="line-582"></span><span>    </span><span id="local-6989586621679057046"><span class="annot"><span class="annottext">get :: Get [a]
</span><a href="#local-6989586621679057046"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679057045"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057045"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-583"></span><span>             </span><span class="annot"><span class="annottext">Int -&gt; Get [a]
forall a. Binary a =&gt; Int -&gt; Get [a]
</span><a href="Data.Binary.Class.html#getMany"><span class="hs-identifier hs-var">getMany</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057045"><span class="hs-identifier hs-var">n</span></a></span></span><span>
</span><span id="line-584"></span><span>
</span><span id="line-585"></span><span class="hs-comment">-- | @'getMany' n@ get @n@ elements in order, without blowing the stack.</span><span>
</span><span id="line-586"></span><span id="local-6989586621679058295"><span class="annot"><a href="Data.Binary.Class.html#getMany"><span class="hs-identifier hs-type">getMany</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058295"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679058295"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-587"></span><span id="getMany"><span class="annot"><span class="annottext">getMany :: forall a. Binary a =&gt; Int -&gt; Get [a]
</span><a href="Data.Binary.Class.html#getMany"><span class="hs-identifier hs-var hs-var">getMany</span></a></span></span><span> </span><span id="local-6989586621679057038"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057038"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Int -&gt; Get [a]
forall {t} {a}. (Eq t, Num t, Binary a) =&gt; [a] -&gt; t -&gt; Get [a]
</span><a href="#local-6989586621679057037"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679057038"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-588"></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-589"></span><span>    </span><span id="local-6989586621679057037"><span class="annot"><span class="annottext">go :: [a] -&gt; t -&gt; Get [a]
</span><a href="#local-6989586621679057037"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679057026"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057026"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Get [a]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">([a] -&gt; Get [a]) -&gt; [a] -&gt; Get [a]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; [a]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#reverse"><span class="hs-identifier hs-var">reverse</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057026"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-590"></span><span>    </span><span class="annot"><a href="#local-6989586621679057037"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621679057025"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057025"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span id="local-6989586621679057024"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679057024"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679057023"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057023"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-591"></span><span>                 </span><span class="hs-comment">-- we must seq x to avoid stack overflows due to laziness in</span><span>
</span><span id="line-592"></span><span>                 </span><span class="hs-comment">-- (&gt;&gt;=)</span><span>
</span><span id="line-593"></span><span>                 </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057023"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Get [a] -&gt; Get [a]
</span><span class="hs-operator hs-var">`seq`</span></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; t -&gt; Get [a]
</span><a href="#local-6989586621679057037"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057023"><span class="hs-identifier hs-var">x</span></a></span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; [a]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679057025"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679057024"><span class="hs-identifier hs-var">i</span></a></span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-594"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#getMany"><span class="hs-pragma hs-type">getMany</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-595"></span><span>
</span><span id="line-596"></span><span id="local-6989586621679058290"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057019"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058290"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058290"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-597"></span><span>    </span><span id="local-6989586621679057014"><span class="annot"><span class="annottext">put :: Maybe a -&gt; Put
</span><a href="#local-6989586621679057014"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-598"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679057013"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057013"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679057013"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-599"></span><span>    </span><span id="local-6989586621679057006"><span class="annot"><span class="annottext">get :: Get (Maybe a)
</span><a href="#local-6989586621679057006"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-600"></span><span>        </span><span id="local-6989586621679057005"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057005"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-601"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679057005"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-602"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Get (Maybe a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-603"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Maybe a) -&gt; Get a -&gt; Get (Maybe a)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-604"></span><span>
</span><span id="line-605"></span><span id="local-6989586621679058288"><span id="local-6989586621679058289"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679057001"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058289"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058288"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058289"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058288"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-606"></span><span>    </span><span id="local-6989586621679056994"><span class="annot"><span class="annottext">put :: Either a b -&gt; Put
</span><a href="#local-6989586621679056994"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span>  </span><span id="local-6989586621679056993"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056993"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056993"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-607"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621679056992"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679056992"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679056992"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-608"></span><span>    </span><span id="local-6989586621679056984"><span class="annot"><span class="annottext">get :: Get (Either a b)
</span><a href="#local-6989586621679056984"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-609"></span><span>        </span><span id="local-6989586621679056983"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056983"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-610"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056983"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-611"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Either a b) -&gt; Get a -&gt; Get (Either a b)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Either a b
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span>  </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-612"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(b -&gt; Either a b) -&gt; Get b -&gt; Get (Either a b)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Either a b
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span><span>
</span><span id="line-613"></span><span>
</span><span id="line-614"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-615"></span><span class="hs-comment">-- ByteStrings (have specially efficient instances)</span><span>
</span><span id="line-616"></span><span>
</span><span id="line-617"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056979"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">B.ByteString</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-618"></span><span>    </span><span id="local-6989586621679056976"><span class="annot"><span class="annottext">put :: ByteString -&gt; Put
</span><a href="#local-6989586621679056976"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056975"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056975"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.html#length"><span class="hs-identifier hs-var">B.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056975"><span class="hs-identifier hs-var">bs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-619"></span><span>             </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Put
</span><a href="Data.Binary.Put.html#putByteString"><span class="hs-identifier hs-var">putByteString</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056975"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-620"></span><span>    </span><span id="local-6989586621679056970"><span class="annot"><span class="annottext">get :: Get ByteString
</span><a href="#local-6989586621679056970"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int -&gt; (Int -&gt; Get ByteString) -&gt; Get ByteString
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get ByteString
</span><a href="Data.Binary.Get.Internal.html#getByteString"><span class="hs-identifier hs-var">getByteString</span></a></span><span>
</span><span id="line-621"></span><span>
</span><span id="line-622"></span><span class="hs-comment">--</span><span>
</span><span id="line-623"></span><span class="hs-comment">-- Using old versions of fps, this is a type synonym, and non portable</span><span>
</span><span id="line-624"></span><span class="hs-comment">--</span><span>
</span><span id="line-625"></span><span class="hs-comment">-- Requires 'flexible instances'</span><span>
</span><span id="line-626"></span><span class="hs-comment">--</span><span>
</span><span id="line-627"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056965"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Lazy.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-628"></span><span>    </span><span id="local-6989586621679056960"><span class="annot"><span class="annottext">put :: ByteString -&gt; Put
</span><a href="#local-6989586621679056960"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056959"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056959"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ByteString -&gt; Int64
</span><a href="../../bytestring/src/Data.ByteString.Lazy.html#length"><span class="hs-identifier hs-var">L.length</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056959"><span class="hs-identifier hs-var">bs</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span>
</span><span id="line-629"></span><span>             </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; Put
</span><a href="Data.Binary.Put.html#putLazyByteString"><span class="hs-identifier hs-var">putLazyByteString</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621679056959"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-630"></span><span>    </span><span id="local-6989586621679056954"><span class="annot"><span class="annottext">get :: Get ByteString
</span><a href="#local-6989586621679056954"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int64
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int64 -&gt; (Int64 -&gt; Get ByteString) -&gt; Get ByteString
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Get ByteString
</span><a href="Data.Binary.Get.html#getLazyByteString"><span class="hs-identifier hs-var">getLazyByteString</span></a></span><span class="hs-cpp">


#if MIN_VERSION_bytestring(0,10,4)
</span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056949"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Short.Internal.html#ShortByteString"><span class="hs-identifier hs-type">BS.ShortByteString</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-635"></span><span>   </span><span id="local-6989586621679056946"><span class="annot"><span class="annottext">put :: ShortByteString -&gt; Put
</span><a href="#local-6989586621679056946"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056945"><span class="annot"><span class="annottext">ShortByteString
</span><a href="#local-6989586621679056945"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ShortByteString -&gt; Int
</span><a href="../../bytestring/src/Data.ByteString.Short.Internal.html#length"><span class="hs-identifier hs-var">BS.length</span></a></span><span> </span><span class="annot"><span class="annottext">ShortByteString
</span><a href="#local-6989586621679056945"><span class="hs-identifier hs-var">bs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-636"></span><span>            </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ShortByteString -&gt; Put
</span><a href="Data.Binary.Put.html#putShortByteString"><span class="hs-identifier hs-var">putShortByteString</span></a></span><span> </span><span class="annot"><span class="annottext">ShortByteString
</span><a href="#local-6989586621679056945"><span class="hs-identifier hs-var">bs</span></a></span><span>
</span><span id="line-637"></span><span>   </span><span id="local-6989586621679056939"><span class="annot"><span class="annottext">get :: Get ShortByteString
</span><a href="#local-6989586621679056939"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int -&gt; (Int -&gt; Get ShortByteString) -&gt; Get ShortByteString
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">(ByteString -&gt; ShortByteString)
-&gt; Get ByteString -&gt; Get ShortByteString
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; ShortByteString
</span><a href="../../bytestring/src/Data.ByteString.Short.Internal.html#toShort"><span class="hs-identifier hs-var">BS.toShort</span></a></span><span> </span><span class="annot"><span class="annottext">(Get ByteString -&gt; Get ShortByteString)
-&gt; (Int -&gt; Get ByteString) -&gt; Int -&gt; Get ShortByteString
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get ByteString
</span><a href="Data.Binary.Get.Internal.html#getByteString"><span class="hs-identifier hs-var">getByteString</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-640"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-641"></span><span class="hs-comment">-- Maps and Sets</span><span>
</span><span id="line-642"></span><span>
</span><span id="line-643"></span><span id="local-6989586621679058285"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056934"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058285"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Set.Internal.html#Set"><span class="hs-identifier hs-type">Set.Set</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058285"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-644"></span><span>    </span><span id="local-6989586621679056928"><span class="annot"><span class="annottext">put :: Set a -&gt; Put
</span><a href="#local-6989586621679056928"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056927"><span class="annot"><span class="annottext">Set a
</span><a href="#local-6989586621679056927"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Set a -&gt; Int
forall a. Set a -&gt; Int
</span><a href="../../containers/src/Data.Set.Internal.html#size"><span class="hs-identifier hs-var">Set.size</span></a></span><span> </span><span class="annot"><span class="annottext">Set a
</span><a href="#local-6989586621679056927"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; [a] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Set a -&gt; [a]
forall a. Set a -&gt; [a]
</span><a href="../../containers/src/Data.Set.Internal.html#toAscList"><span class="hs-identifier hs-var">Set.toAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Set a
</span><a href="#local-6989586621679056927"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-645"></span><span>    </span><span id="local-6989586621679056922"><span class="annot"><span class="annottext">get :: Get (Set a)
</span><a href="#local-6989586621679056922"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([a] -&gt; Set a) -&gt; Get [a] -&gt; Get (Set a)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Set a
forall a. [a] -&gt; Set a
</span><a href="../../containers/src/Data.Set.Internal.html#fromDistinctAscList"><span class="hs-identifier hs-var">Set.fromDistinctAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Get [a]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-646"></span><span>
</span><span id="line-647"></span><span id="local-6989586621679058280"><span id="local-6989586621679058281"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056917"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058281"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058280"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Map.Internal.html#Map"><span class="hs-identifier hs-type">Map.Map</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058281"><span class="hs-identifier hs-type">k</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058280"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-648"></span><span>    </span><span id="local-6989586621679056911"><span class="annot"><span class="annottext">put :: Map k e -&gt; Put
</span><a href="#local-6989586621679056911"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056910"><span class="annot"><span class="annottext">Map k e
</span><a href="#local-6989586621679056910"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Map k e -&gt; Int
forall k a. Map k a -&gt; Int
</span><a href="../../containers/src/Data.Map.Internal.html#size"><span class="hs-identifier hs-var">Map.size</span></a></span><span> </span><span class="annot"><span class="annottext">Map k e
</span><a href="#local-6989586621679056910"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">((k, e) -&gt; Put) -&gt; [(k, e)] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">(k, e) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Map k e -&gt; [(k, e)]
forall k a. Map k a -&gt; [(k, a)]
</span><a href="../../containers/src/Data.Map.Internal.html#toAscList"><span class="hs-identifier hs-var">Map.toAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Map k e
</span><a href="#local-6989586621679056910"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-649"></span><span>    </span><span id="local-6989586621679056904"><span class="annot"><span class="annottext">get :: Get (Map k e)
</span><a href="#local-6989586621679056904"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([(k, e)] -&gt; Map k e) -&gt; Get [(k, e)] -&gt; Get (Map k e)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[(k, e)] -&gt; Map k e
forall k a. [(k, a)] -&gt; Map k a
</span><a href="../../containers/src/Data.Map.Internal.html#fromDistinctAscList"><span class="hs-identifier hs-var">Map.fromDistinctAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Get [(k, e)]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span></span><span>
</span><span id="line-650"></span><span>
</span><span id="line-651"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056899"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet.IntSet</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-652"></span><span>    </span><span id="local-6989586621679056893"><span class="annot"><span class="annottext">put :: IntSet -&gt; Put
</span><a href="#local-6989586621679056893"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056892"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621679056892"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Int
</span><a href="../../containers/src/Data.IntSet.Internal.html#size"><span class="hs-identifier hs-var">IntSet.size</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621679056892"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Put) -&gt; [Int] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; [Int]
</span><a href="../../containers/src/Data.IntSet.Internal.html#toAscList"><span class="hs-identifier hs-var">IntSet.toAscList</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621679056892"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-653"></span><span>    </span><span id="local-6989586621679056886"><span class="annot"><span class="annottext">get :: Get IntSet
</span><a href="#local-6989586621679056886"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Int] -&gt; IntSet) -&gt; Get [Int] -&gt; Get IntSet
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Int] -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#fromDistinctAscList"><span class="hs-identifier hs-var">IntSet.fromDistinctAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Get [Int]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-654"></span><span>
</span><span id="line-655"></span><span id="local-6989586621679058273"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056881"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058273"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap.IntMap</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058273"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-656"></span><span>    </span><span id="local-6989586621679056875"><span class="annot"><span class="annottext">put :: IntMap e -&gt; Put
</span><a href="#local-6989586621679056875"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056874"><span class="annot"><span class="annottext">IntMap e
</span><a href="#local-6989586621679056874"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap e -&gt; Int
forall a. IntMap a -&gt; Int
</span><a href="../../containers/src/Data.IntMap.Internal.html#size"><span class="hs-identifier hs-var">IntMap.size</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap e
</span><a href="#local-6989586621679056874"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">((Int, e) -&gt; Put) -&gt; [(Int, e)] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, e) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap e -&gt; [(Int, e)]
forall a. IntMap a -&gt; [(Int, a)]
</span><a href="../../containers/src/Data.IntMap.Internal.html#toAscList"><span class="hs-identifier hs-var">IntMap.toAscList</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap e
</span><a href="#local-6989586621679056874"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-657"></span><span>    </span><span id="local-6989586621679056867"><span class="annot"><span class="annottext">get :: Get (IntMap e)
</span><a href="#local-6989586621679056867"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([(Int, e)] -&gt; IntMap e) -&gt; Get [(Int, e)] -&gt; Get (IntMap e)
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[(Int, e)] -&gt; IntMap e
forall a. [(Int, a)] -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Internal.html#fromDistinctAscList"><span class="hs-identifier hs-var">IntMap.fromDistinctAscList</span></a></span><span> </span><span class="annot"><span class="annottext">Get [(Int, e)]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-658"></span><span>
</span><span id="line-659"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-660"></span><span class="hs-comment">-- Queues and Sequences</span><span>
</span><span id="line-661"></span><span>
</span><span id="line-662"></span><span class="hs-comment">--</span><span>
</span><span id="line-663"></span><span class="hs-comment">-- This is valid Hugs, but you need the most recent Hugs</span><span>
</span><span id="line-664"></span><span class="hs-comment">--</span><span>
</span><span id="line-665"></span><span>
</span><span id="line-666"></span><span id="local-6989586621679058269"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056862"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058269"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Sequence.Internal.html#Seq"><span class="hs-identifier hs-type">Seq.Seq</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058269"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-667"></span><span>    </span><span id="local-6989586621679056855"><span class="annot"><span class="annottext">put :: Seq e -&gt; Put
</span><a href="#local-6989586621679056855"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056854"><span class="annot"><span class="annottext">Seq e
</span><a href="#local-6989586621679056854"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Seq e -&gt; Int
forall a. Seq a -&gt; Int
</span><a href="../../containers/src/Data.Sequence.Internal.html#length"><span class="hs-identifier hs-var">Seq.length</span></a></span><span> </span><span class="annot"><span class="annottext">Seq e
</span><a href="#local-6989586621679056854"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(e -&gt; Put) -&gt; Seq e -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">Fold.mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Seq e
</span><a href="#local-6989586621679056854"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-668"></span><span>    </span><span id="local-6989586621679056846"><span class="annot"><span class="annottext">get :: Get (Seq e)
</span><a href="#local-6989586621679056846"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679056845"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056845"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-669"></span><span>             </span><span class="annot"><span class="annottext">Seq e -&gt; Int -&gt; Get e -&gt; Get (Seq e)
forall {t} {m :: * -&gt; *} {a}.
(Eq t, Num t, Monad m) =&gt;
Seq a -&gt; t -&gt; m a -&gt; m (Seq a)
</span><a href="#local-6989586621679056844"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="annot"><span class="annottext">Seq e
forall a. Seq a
</span><a href="../../containers/src/Data.Sequence.Internal.html#empty"><span class="hs-identifier hs-var">Seq.empty</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056845"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Get e
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-670"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679056844"><span class="annot"><span class="annottext">rep :: Seq a -&gt; t -&gt; m a -&gt; m (Seq a)
</span><a href="#local-6989586621679056844"><span class="hs-identifier hs-var hs-var">rep</span></a></span></span><span> </span><span id="local-6989586621679056833"><span class="annot"><span class="annottext">Seq a
</span><a href="#local-6989586621679056833"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">m a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Seq a -&gt; m (Seq a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Seq a -&gt; m (Seq a)) -&gt; Seq a -&gt; m (Seq a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Seq a
</span><a href="#local-6989586621679056833"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-671"></span><span>            </span><span class="annot"><a href="#local-6989586621679056844"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span id="local-6989586621679056832"><span class="annot"><span class="annottext">Seq a
</span><a href="#local-6989586621679056832"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span id="local-6989586621679056831"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679056831"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679056830"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679056830"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Seq a
</span><a href="#local-6989586621679056832"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="annot"><span class="annottext">Seq a -&gt; m (Seq a) -&gt; m (Seq a)
</span><span class="hs-operator hs-var">`seq`</span></span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679056831"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; m (Seq a) -&gt; m (Seq a)
</span><span class="hs-operator hs-var">`seq`</span></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-672"></span><span>                           </span><span id="local-6989586621679056829"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056829"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679056830"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-673"></span><span>                           </span><span class="annot"><span class="annottext">Seq a -&gt; t -&gt; m a -&gt; m (Seq a)
</span><a href="#local-6989586621679056844"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Seq a
</span><a href="#local-6989586621679056832"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="annot"><span class="annottext">Seq a -&gt; a -&gt; Seq a
forall a. Seq a -&gt; a -&gt; Seq a
</span><a href="../../containers/src/Data.Sequence.Internal.html#%7C%3E"><span class="hs-operator hs-var">Seq.|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056829"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679056831"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679056830"><span class="hs-identifier hs-var">g</span></a></span></span><span>
</span><span id="line-674"></span><span>
</span><span id="line-675"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-676"></span><span class="hs-comment">-- Floating point</span><span>
</span><span id="line-677"></span><span>
</span><span id="line-678"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056824"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-679"></span><span>    </span><span id="local-6989586621679056818"><span class="annot"><span class="annottext">put :: Double -&gt; Put
</span><a href="#local-6989586621679056818"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056817"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679056817"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer, Int) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Double -&gt; (Integer, Int)
forall a. RealFloat a =&gt; a -&gt; (Integer, Int)
</span><a href="../../base/src/GHC.Float.html#decodeFloat"><span class="hs-identifier hs-var">decodeFloat</span></a></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679056817"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-680"></span><span>    </span><span id="local-6989586621679056809"><span class="annot"><span class="annottext">get :: Get Double
</span><a href="#local-6989586621679056809"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-681"></span><span>        </span><span id="local-6989586621679056808"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679056808"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Integer
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-682"></span><span>        </span><span id="local-6989586621679056807"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056807"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-683"></span><span>        </span><span class="annot"><span class="annottext">Double -&gt; Get Double
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Double -&gt; Get Double) -&gt; Double -&gt; Get Double
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; Double
forall a. RealFloat a =&gt; Integer -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Float.html#encodeFloat"><span class="hs-identifier hs-var">encodeFloat</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679056808"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056807"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-684"></span><span>
</span><span id="line-685"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056802"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-686"></span><span>    </span><span id="local-6989586621679056796"><span class="annot"><span class="annottext">put :: Float -&gt; Put
</span><a href="#local-6989586621679056796"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056795"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679056795"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer, Int) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Float -&gt; (Integer, Int)
forall a. RealFloat a =&gt; a -&gt; (Integer, Int)
</span><a href="../../base/src/GHC.Float.html#decodeFloat"><span class="hs-identifier hs-var">decodeFloat</span></a></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679056795"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-687"></span><span>    </span><span id="local-6989586621679056788"><span class="annot"><span class="annottext">get :: Get Float
</span><a href="#local-6989586621679056788"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-688"></span><span>        </span><span id="local-6989586621679056787"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679056787"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Integer
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-689"></span><span>        </span><span id="local-6989586621679056786"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056786"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-690"></span><span>        </span><span class="annot"><span class="annottext">Float -&gt; Get Float
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Float -&gt; Get Float) -&gt; Float -&gt; Get Float
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int -&gt; Float
forall a. RealFloat a =&gt; Integer -&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Float.html#encodeFloat"><span class="hs-identifier hs-var">encodeFloat</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679056787"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056786"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-691"></span><span>
</span><span id="line-692"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-693"></span><span class="hs-comment">-- Trees</span><span>
</span><span id="line-694"></span><span>
</span><span id="line-695"></span><span id="local-6989586621679058261"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056782"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058261"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">T.Tree</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058261"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-696"></span><span>    </span><span id="local-6989586621679056777"><span class="annot"><span class="annottext">put :: Tree e -&gt; Put
</span><a href="#local-6989586621679056777"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">T.Node</span></a></span><span> </span><span id="local-6989586621679056775"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679056775"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679056774"><span class="annot"><span class="annottext">[Tree e]
</span><a href="#local-6989586621679056774"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">e -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679056775"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree e] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree e]
</span><a href="#local-6989586621679056774"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-697"></span><span>    </span><span id="local-6989586621679056769"><span class="annot"><span class="annottext">get :: Get (Tree e)
</span><a href="#local-6989586621679056769"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(e -&gt; [Tree e] -&gt; Tree e) -&gt; Get e -&gt; Get [Tree e] -&gt; Get (Tree e)
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; [Tree e] -&gt; Tree e
forall a. a -&gt; [Tree a] -&gt; Tree a
</span><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-var">T.Node</span></a></span><span> </span><span class="annot"><span class="annottext">Get e
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get [Tree e]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span></span><span>
</span><span id="line-698"></span><span>
</span><span id="line-699"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-700"></span><span class="hs-comment">-- Arrays</span><span>
</span><span id="line-701"></span><span>
</span><span id="line-702"></span><span id="local-6989586621679058258"><span id="local-6989586621679058259"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056765"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058259"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Ix.html#Ix"><span class="hs-identifier hs-type">Ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058259"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058258"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058259"><span class="hs-identifier hs-type">i</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058258"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-703"></span><span>    </span><span id="local-6989586621679056749"><span class="annot"><span class="annottext">put :: Array i e -&gt; Put
</span><a href="#local-6989586621679056749"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056748"><span class="annot"><span class="annottext">Array i e
</span><a href="#local-6989586621679056748"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-704"></span><span>        </span><span class="annot"><span class="annottext">(i, i) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Array i e -&gt; (i, i)
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
a i e -&gt; (i, i)
</span><a href="../../array/src/Data.Array.Base.html#bounds"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">Array i e
</span><a href="#local-6989586621679056748"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-705"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(i, i) -&gt; Int
forall a. Ix a =&gt; (a, a) -&gt; Int
</span><a href="../../base/src/GHC.Ix.html#rangeSize"><span class="hs-identifier hs-var">rangeSize</span></a></span><span> </span><span class="annot"><span class="annottext">((i, i) -&gt; Int) -&gt; (i, i) -&gt; Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Array i e -&gt; (i, i)
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
a i e -&gt; (i, i)
</span><a href="../../array/src/Data.Array.Base.html#bounds"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">Array i e
</span><a href="#local-6989586621679056748"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-comment">-- write the length</span><span>
</span><span id="line-706"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(e -&gt; Put) -&gt; [e] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Array i e -&gt; [e]
forall (a :: * -&gt; * -&gt; *) e i. (IArray a e, Ix i) =&gt; a i e -&gt; [e]
</span><a href="../../array/src/Data.Array.Base.html#elems"><span class="hs-identifier hs-var">elems</span></a></span><span> </span><span class="annot"><span class="annottext">Array i e
</span><a href="#local-6989586621679056748"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>        </span><span class="hs-comment">-- now the elems.</span><span>
</span><span id="line-707"></span><span>    </span><span id="local-6989586621679056735"><span class="annot"><span class="annottext">get :: Get (Array i e)
</span><a href="#local-6989586621679056735"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-708"></span><span>        </span><span id="local-6989586621679056734"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679056734"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (i, i)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-709"></span><span>        </span><span id="local-6989586621679056733"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056733"><span class="hs-identifier hs-var">n</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>                  </span><span class="hs-comment">-- read the length</span><span>
</span><span id="line-710"></span><span>        </span><span id="local-6989586621679056732"><span class="annot"><span class="annottext">[e]
</span><a href="#local-6989586621679056732"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get [e]
forall a. Binary a =&gt; Int -&gt; Get [a]
</span><a href="Data.Binary.Class.html#getMany"><span class="hs-identifier hs-var">getMany</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056733"><span class="hs-identifier hs-var">n</span></a></span><span>            </span><span class="hs-comment">-- now the elems.</span><span>
</span><span id="line-711"></span><span>        </span><span class="annot"><span class="annottext">Array i e -&gt; Get (Array i e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(i, i) -&gt; [e] -&gt; Array i e
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
(i, i) -&gt; [e] -&gt; a i e
</span><a href="../../array/src/Data.Array.Base.html#listArray"><span class="hs-identifier hs-var">listArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679056734"><span class="hs-identifier hs-var">bs</span></a></span><span> </span><span class="annot"><span class="annottext">[e]
</span><a href="#local-6989586621679056732"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-712"></span><span>
</span><span id="line-713"></span><span class="hs-comment">--</span><span>
</span><span id="line-714"></span><span class="hs-comment">-- The IArray UArray e constraint is non portable. Requires flexible instances</span><span>
</span><span id="line-715"></span><span class="hs-comment">--</span><span>
</span><span id="line-716"></span><span id="local-6989586621679058245"><span id="local-6989586621679058246"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056727"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058246"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Ix.html#Ix"><span class="hs-identifier hs-type">Ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058246"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058245"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#IArray"><span class="hs-identifier hs-type">IArray</span></a></span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058245"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058246"><span class="hs-identifier hs-type">i</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058245"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-717"></span><span>    </span><span id="local-6989586621679056712"><span class="annot"><span class="annottext">put :: UArray i e -&gt; Put
</span><a href="#local-6989586621679056712"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056711"><span class="annot"><span class="annottext">UArray i e
</span><a href="#local-6989586621679056711"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-718"></span><span>        </span><span class="annot"><span class="annottext">(i, i) -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UArray i e -&gt; (i, i)
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
a i e -&gt; (i, i)
</span><a href="../../array/src/Data.Array.Base.html#bounds"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">UArray i e
</span><a href="#local-6989586621679056711"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-719"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(i, i) -&gt; Int
forall a. Ix a =&gt; (a, a) -&gt; Int
</span><a href="../../base/src/GHC.Ix.html#rangeSize"><span class="hs-identifier hs-var">rangeSize</span></a></span><span> </span><span class="annot"><span class="annottext">((i, i) -&gt; Int) -&gt; (i, i) -&gt; Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">UArray i e -&gt; (i, i)
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
a i e -&gt; (i, i)
</span><a href="../../array/src/Data.Array.Base.html#bounds"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">UArray i e
</span><a href="#local-6989586621679056711"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-comment">-- now write the length</span><span>
</span><span id="line-720"></span><span>        </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(e -&gt; Put) -&gt; [e] -&gt; Put
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UArray i e -&gt; [e]
forall (a :: * -&gt; * -&gt; *) e i. (IArray a e, Ix i) =&gt; a i e -&gt; [e]
</span><a href="../../array/src/Data.Array.Base.html#elems"><span class="hs-identifier hs-var">elems</span></a></span><span> </span><span class="annot"><span class="annottext">UArray i e
</span><a href="#local-6989586621679056711"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-721"></span><span>    </span><span id="local-6989586621679056701"><span class="annot"><span class="annottext">get :: Get (UArray i e)
</span><a href="#local-6989586621679056701"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-722"></span><span>        </span><span id="local-6989586621679056700"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679056700"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get (i, i)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-723"></span><span>        </span><span id="local-6989586621679056699"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056699"><span class="hs-identifier hs-var">n</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-724"></span><span>        </span><span id="local-6989586621679056698"><span class="annot"><span class="annottext">[e]
</span><a href="#local-6989586621679056698"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Get [e]
forall a. Binary a =&gt; Int -&gt; Get [a]
</span><a href="Data.Binary.Class.html#getMany"><span class="hs-identifier hs-var">getMany</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056699"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-725"></span><span>        </span><span class="annot"><span class="annottext">UArray i e -&gt; Get (UArray i e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(i, i) -&gt; [e] -&gt; UArray i e
forall (a :: * -&gt; * -&gt; *) e i.
(IArray a e, Ix i) =&gt;
(i, i) -&gt; [e] -&gt; a i e
</span><a href="../../array/src/Data.Array.Base.html#listArray"><span class="hs-identifier hs-var">listArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679056700"><span class="hs-identifier hs-var">bs</span></a></span><span> </span><span class="annot"><span class="annottext">[e]
</span><a href="#local-6989586621679056698"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-726"></span><span>
</span><span id="line-727"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-728"></span><span class="hs-comment">-- Fingerprints</span><span>
</span><span id="line-729"></span><span>
</span><span id="line-730"></span><span class="hs-comment">-- | @since 0.7.6.0</span><span>
</span><span id="line-731"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056694"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-732"></span><span>    </span><span id="local-6989586621679056690"><span class="annot"><span class="annottext">put :: Fingerprint -&gt; Put
</span><a href="#local-6989586621679056690"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span id="local-6989586621679056689"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056689"><span class="hs-identifier hs-var">x1</span></a></span></span><span> </span><span id="local-6989586621679056688"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056688"><span class="hs-identifier hs-var">x2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056689"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056688"><span class="hs-identifier hs-var">x2</span></a></span><span>
</span><span id="line-733"></span><span>    </span><span id="local-6989586621679056682"><span class="annot"><span class="annottext">get :: Get Fingerprint
</span><a href="#local-6989586621679056682"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-734"></span><span>        </span><span id="local-6989586621679056681"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056681"><span class="hs-identifier hs-var">x1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word64
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-735"></span><span>        </span><span id="local-6989586621679056680"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056680"><span class="hs-identifier hs-var">x2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word64
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-736"></span><span>        </span><span class="annot"><span class="annottext">Fingerprint -&gt; Get Fingerprint
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Fingerprint -&gt; Get Fingerprint) -&gt; Fingerprint -&gt; Get Fingerprint
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Fingerprint
</span><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-var">Fingerprint</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056681"><span class="hs-identifier hs-var">x1</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679056680"><span class="hs-identifier hs-var">x2</span></a></span><span>
</span><span id="line-737"></span><span>
</span><span id="line-738"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-739"></span><span class="hs-comment">-- Version</span><span>
</span><span id="line-740"></span><span>
</span><span id="line-741"></span><span class="hs-comment">-- | @since 0.8.0.0</span><span>
</span><span id="line-742"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056676"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Version.html#Version"><span class="hs-identifier hs-type">Version</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-743"></span><span>    </span><span id="local-6989586621679056669"><span class="annot"><span class="annottext">put :: Version -&gt; Put
</span><a href="#local-6989586621679056669"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Version.html#Version"><span class="hs-identifier hs-type">Version</span></a></span><span> </span><span id="local-6989586621679056667"><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679056667"><span class="hs-identifier hs-var">br</span></a></span></span><span> </span><span id="local-6989586621679056666"><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679056666"><span class="hs-identifier hs-var">tags</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Int] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679056667"><span class="hs-identifier hs-var">br</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679056666"><span class="hs-identifier hs-var">tags</span></a></span><span>
</span><span id="line-744"></span><span>    </span><span id="local-6989586621679056657"><span class="annot"><span class="annottext">get :: Get Version
</span><a href="#local-6989586621679056657"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Int] -&gt; [String] -&gt; Version
</span><a href="../../base/src/Data.Version.html#Version"><span class="hs-identifier hs-var">Version</span></a></span><span> </span><span class="annot"><span class="annottext">([Int] -&gt; [String] -&gt; Version)
-&gt; Get [Int] -&gt; Get ([String] -&gt; Version)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get [Int]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get ([String] -&gt; Version) -&gt; Get [String] -&gt; Get Version
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get [String]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-745"></span><span>
</span><span id="line-746"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-747"></span><span class="hs-comment">-- Data.Monoid datatypes</span><span>
</span><span id="line-748"></span><span>
</span><span id="line-749"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-750"></span><span id="local-6989586621679058241"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056653"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058241"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#Dual"><span class="hs-identifier hs-type">Monoid.Dual</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058241"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-751"></span><span>  </span><span id="local-6989586621679056650"><span class="annot"><span class="annottext">get :: Get (Dual a)
</span><a href="#local-6989586621679056650"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Dual a) -&gt; Get a -&gt; Get (Dual a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Dual a
forall a. a -&gt; Dual a
</span><a href="../../base/src/Data.Semigroup.Internal.html#Dual"><span class="hs-identifier hs-var">Monoid.Dual</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-752"></span><span>  </span><span id="local-6989586621679056647"><span class="annot"><span class="annottext">put :: Dual a -&gt; Put
</span><a href="#local-6989586621679056647"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Dual a -&gt; a) -&gt; Dual a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Dual a -&gt; a
forall a. Dual a -&gt; a
</span><a href="../../base/src/Data.Semigroup.Internal.html#getDual"><span class="hs-identifier hs-var hs-var">Monoid.getDual</span></a></span></span><span>
</span><span id="line-753"></span><span>
</span><span id="line-754"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-755"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056642"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#All"><span class="hs-identifier hs-type">Monoid.All</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-756"></span><span>  </span><span id="local-6989586621679056639"><span class="annot"><span class="annottext">get :: Get All
</span><a href="#local-6989586621679056639"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; All) -&gt; Get Bool -&gt; Get All
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; All
</span><a href="../../base/src/Data.Semigroup.Internal.html#All"><span class="hs-identifier hs-var">Monoid.All</span></a></span><span> </span><span class="annot"><span class="annottext">Get Bool
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-757"></span><span>  </span><span id="local-6989586621679056636"><span class="annot"><span class="annottext">put :: All -&gt; Put
</span><a href="#local-6989586621679056636"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; Put) -&gt; (All -&gt; Bool) -&gt; All -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">All -&gt; Bool
</span><a href="../../base/src/Data.Semigroup.Internal.html#getAll"><span class="hs-identifier hs-var hs-var">Monoid.getAll</span></a></span><span>
</span><span id="line-758"></span><span>
</span><span id="line-759"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-760"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056631"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#Any"><span class="hs-identifier hs-type">Monoid.Any</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-761"></span><span>  </span><span id="local-6989586621679056628"><span class="annot"><span class="annottext">get :: Get Any
</span><a href="#local-6989586621679056628"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; Any) -&gt; Get Bool -&gt; Get Any
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Any
</span><a href="../../base/src/Data.Semigroup.Internal.html#Any"><span class="hs-identifier hs-var">Monoid.Any</span></a></span><span> </span><span class="annot"><span class="annottext">Get Bool
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-762"></span><span>  </span><span id="local-6989586621679056625"><span class="annot"><span class="annottext">put :: Any -&gt; Put
</span><a href="#local-6989586621679056625"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; Put) -&gt; (Any -&gt; Bool) -&gt; Any -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Any -&gt; Bool
</span><a href="../../base/src/Data.Semigroup.Internal.html#getAny"><span class="hs-identifier hs-var hs-var">Monoid.getAny</span></a></span><span>
</span><span id="line-763"></span><span>
</span><span id="line-764"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-765"></span><span id="local-6989586621679058238"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056620"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058238"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#Sum"><span class="hs-identifier hs-type">Monoid.Sum</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058238"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-766"></span><span>  </span><span id="local-6989586621679056617"><span class="annot"><span class="annottext">get :: Get (Sum a)
</span><a href="#local-6989586621679056617"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Sum a) -&gt; Get a -&gt; Get (Sum a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Sum a
forall a. a -&gt; Sum a
</span><a href="../../base/src/Data.Semigroup.Internal.html#Sum"><span class="hs-identifier hs-var">Monoid.Sum</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-767"></span><span>  </span><span id="local-6989586621679056614"><span class="annot"><span class="annottext">put :: Sum a -&gt; Put
</span><a href="#local-6989586621679056614"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Sum a -&gt; a) -&gt; Sum a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Sum a -&gt; a
forall a. Sum a -&gt; a
</span><a href="../../base/src/Data.Semigroup.Internal.html#getSum"><span class="hs-identifier hs-var hs-var">Monoid.getSum</span></a></span></span><span>
</span><span id="line-768"></span><span>
</span><span id="line-769"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-770"></span><span id="local-6989586621679058235"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056609"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058235"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#Product"><span class="hs-identifier hs-type">Monoid.Product</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058235"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-771"></span><span>  </span><span id="local-6989586621679056606"><span class="annot"><span class="annottext">get :: Get (Product a)
</span><a href="#local-6989586621679056606"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Product a) -&gt; Get a -&gt; Get (Product a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Product a
forall a. a -&gt; Product a
</span><a href="../../base/src/Data.Semigroup.Internal.html#Product"><span class="hs-identifier hs-var">Monoid.Product</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-772"></span><span>  </span><span id="local-6989586621679056603"><span class="annot"><span class="annottext">put :: Product a -&gt; Put
</span><a href="#local-6989586621679056603"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Product a -&gt; a) -&gt; Product a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Product a -&gt; a
forall a. Product a -&gt; a
</span><a href="../../base/src/Data.Semigroup.Internal.html#getProduct"><span class="hs-identifier hs-var hs-var">Monoid.getProduct</span></a></span></span><span>
</span><span id="line-773"></span><span>
</span><span id="line-774"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-775"></span><span id="local-6989586621679058232"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056598"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058232"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Monoid.html#First"><span class="hs-identifier hs-type">Monoid.First</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058232"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-776"></span><span>  </span><span id="local-6989586621679056595"><span class="annot"><span class="annottext">get :: Get (First a)
</span><a href="#local-6989586621679056595"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; First a) -&gt; Get (Maybe a) -&gt; Get (First a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; First a
forall a. Maybe a -&gt; First a
</span><a href="../../base/src/Data.Monoid.html#First"><span class="hs-identifier hs-var">Monoid.First</span></a></span><span> </span><span class="annot"><span class="annottext">Get (Maybe a)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-777"></span><span>  </span><span id="local-6989586621679056592"><span class="annot"><span class="annottext">put :: First a -&gt; Put
</span><a href="#local-6989586621679056592"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; Put) -&gt; (First a -&gt; Maybe a) -&gt; First a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">First a -&gt; Maybe a
forall a. First a -&gt; Maybe a
</span><a href="../../base/src/Data.Monoid.html#getFirst"><span class="hs-identifier hs-var hs-var">Monoid.getFirst</span></a></span></span><span>
</span><span id="line-778"></span><span>
</span><span id="line-779"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-780"></span><span id="local-6989586621679058229"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056587"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058229"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Monoid.html#Last"><span class="hs-identifier hs-type">Monoid.Last</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058229"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-781"></span><span>  </span><span id="local-6989586621679056584"><span class="annot"><span class="annottext">get :: Get (Last a)
</span><a href="#local-6989586621679056584"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; Last a) -&gt; Get (Maybe a) -&gt; Get (Last a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Last a
forall a. Maybe a -&gt; Last a
</span><a href="../../base/src/Data.Monoid.html#Last"><span class="hs-identifier hs-var">Monoid.Last</span></a></span><span> </span><span class="annot"><span class="annottext">Get (Maybe a)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-782"></span><span>  </span><span id="local-6989586621679056581"><span class="annot"><span class="annottext">put :: Last a -&gt; Put
</span><a href="#local-6989586621679056581"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; Put) -&gt; (Last a -&gt; Maybe a) -&gt; Last a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Last a -&gt; Maybe a
forall a. Last a -&gt; Maybe a
</span><a href="../../base/src/Data.Monoid.html#getLast"><span class="hs-identifier hs-var hs-var">Monoid.getLast</span></a></span></span><span class="hs-cpp">

#if MIN_VERSION_base(4,8,0)
</span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-786"></span><span id="local-6989586621679058224"><span id="local-6989586621679058225"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056576"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058225"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058224"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.Internal.html#Alt"><span class="hs-identifier hs-type">Monoid.Alt</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058225"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058224"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-787"></span><span>  </span><span id="local-6989586621679056573"><span class="annot"><span class="annottext">get :: Get (Alt f a)
</span><a href="#local-6989586621679056573"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(f a -&gt; Alt f a) -&gt; Get (f a) -&gt; Get (Alt f a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">f a -&gt; Alt f a
forall {k} (f :: k -&gt; *) (a :: k). f a -&gt; Alt f a
</span><a href="../../base/src/Data.Semigroup.Internal.html#Alt"><span class="hs-identifier hs-var">Monoid.Alt</span></a></span><span> </span><span class="annot"><span class="annottext">Get (f a)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-788"></span><span>  </span><span id="local-6989586621679056570"><span class="annot"><span class="annottext">put :: Alt f a -&gt; Put
</span><a href="#local-6989586621679056570"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">f a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(f a -&gt; Put) -&gt; (Alt f a -&gt; f a) -&gt; Alt f a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Alt f a -&gt; f a
forall {k} (f :: k -&gt; *) (a :: k). Alt f a -&gt; f a
</span><a href="../../base/src/Data.Semigroup.Internal.html#getAlt"><span class="hs-identifier hs-var hs-var">Monoid.getAlt</span></a></span></span></span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">
#if MIN_VERSION_base(4,9,0)
</span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-793"></span><span class="hs-comment">-- Data.Semigroup datatypes</span><span>
</span><span id="line-794"></span><span>
</span><span id="line-795"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-796"></span><span id="local-6989586621679058217"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056565"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058217"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Min"><span class="hs-identifier hs-type">Semigroup.Min</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058217"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-797"></span><span>  </span><span id="local-6989586621679056562"><span class="annot"><span class="annottext">get :: Get (Min a)
</span><a href="#local-6989586621679056562"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Min a) -&gt; Get a -&gt; Get (Min a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Min a
forall a. a -&gt; Min a
</span><a href="../../base/src/Data.Semigroup.html#Min"><span class="hs-identifier hs-var">Semigroup.Min</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-798"></span><span>  </span><span id="local-6989586621679056559"><span class="annot"><span class="annottext">put :: Min a -&gt; Put
</span><a href="#local-6989586621679056559"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Min a -&gt; a) -&gt; Min a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Min a -&gt; a
forall a. Min a -&gt; a
</span><a href="../../base/src/Data.Semigroup.html#getMin"><span class="hs-identifier hs-var hs-var">Semigroup.getMin</span></a></span></span><span>
</span><span id="line-799"></span><span>
</span><span id="line-800"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-801"></span><span id="local-6989586621679058214"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056554"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058214"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Max"><span class="hs-identifier hs-type">Semigroup.Max</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058214"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-802"></span><span>  </span><span id="local-6989586621679056551"><span class="annot"><span class="annottext">get :: Get (Max a)
</span><a href="#local-6989586621679056551"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Max a) -&gt; Get a -&gt; Get (Max a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Max a
forall a. a -&gt; Max a
</span><a href="../../base/src/Data.Semigroup.html#Max"><span class="hs-identifier hs-var">Semigroup.Max</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-803"></span><span>  </span><span id="local-6989586621679056548"><span class="annot"><span class="annottext">put :: Max a -&gt; Put
</span><a href="#local-6989586621679056548"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Max a -&gt; a) -&gt; Max a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Max a -&gt; a
forall a. Max a -&gt; a
</span><a href="../../base/src/Data.Semigroup.html#getMax"><span class="hs-identifier hs-var hs-var">Semigroup.getMax</span></a></span></span><span>
</span><span id="line-804"></span><span>
</span><span id="line-805"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-806"></span><span id="local-6989586621679058211"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056543"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058211"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#First"><span class="hs-identifier hs-type">Semigroup.First</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058211"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-807"></span><span>  </span><span id="local-6989586621679056540"><span class="annot"><span class="annottext">get :: Get (First a)
</span><a href="#local-6989586621679056540"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; First a) -&gt; Get a -&gt; Get (First a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; First a
forall a. a -&gt; First a
</span><a href="../../base/src/Data.Semigroup.html#First"><span class="hs-identifier hs-var">Semigroup.First</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-808"></span><span>  </span><span id="local-6989586621679056537"><span class="annot"><span class="annottext">put :: First a -&gt; Put
</span><a href="#local-6989586621679056537"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (First a -&gt; a) -&gt; First a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">First a -&gt; a
forall a. First a -&gt; a
</span><a href="../../base/src/Data.Semigroup.html#getFirst"><span class="hs-identifier hs-var hs-var">Semigroup.getFirst</span></a></span></span><span>
</span><span id="line-809"></span><span>
</span><span id="line-810"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-811"></span><span id="local-6989586621679058208"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056532"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058208"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Last"><span class="hs-identifier hs-type">Semigroup.Last</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058208"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-812"></span><span>  </span><span id="local-6989586621679056529"><span class="annot"><span class="annottext">get :: Get (Last a)
</span><a href="#local-6989586621679056529"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; Last a) -&gt; Get a -&gt; Get (Last a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Last a
forall a. a -&gt; Last a
</span><a href="../../base/src/Data.Semigroup.html#Last"><span class="hs-identifier hs-var">Semigroup.Last</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-813"></span><span>  </span><span id="local-6989586621679056526"><span class="annot"><span class="annottext">put :: Last a -&gt; Put
</span><a href="#local-6989586621679056526"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Put) -&gt; (Last a -&gt; a) -&gt; Last a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Last a -&gt; a
forall a. Last a -&gt; a
</span><a href="../../base/src/Data.Semigroup.html#getLast"><span class="hs-identifier hs-var hs-var">Semigroup.getLast</span></a></span></span><span>
</span><span id="line-814"></span><span>
</span><span id="line-815"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-816"></span><span id="local-6989586621679058205"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056521"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058205"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Option"><span class="hs-identifier hs-type">Semigroup.Option</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058205"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-817"></span><span>  </span><span id="local-6989586621679056518"><span class="annot"><span class="annottext">get :: Get (Option a)
</span><a href="#local-6989586621679056518"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; Option a) -&gt; Get (Maybe a) -&gt; Get (Option a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Option a
forall a. Maybe a -&gt; Option a
</span><a href="../../base/src/Data.Semigroup.html#Option"><span class="hs-identifier hs-var">Semigroup.Option</span></a></span><span> </span><span class="annot"><span class="annottext">Get (Maybe a)
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-818"></span><span>  </span><span id="local-6989586621679056515"><span class="annot"><span class="annottext">put :: Option a -&gt; Put
</span><a href="#local-6989586621679056515"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(Maybe a -&gt; Put) -&gt; (Option a -&gt; Maybe a) -&gt; Option a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Option a -&gt; Maybe a
forall a. Option a -&gt; Maybe a
</span><a href="../../base/src/Data.Semigroup.html#getOption"><span class="hs-identifier hs-var hs-var">Semigroup.getOption</span></a></span></span><span>
</span><span id="line-819"></span><span>
</span><span id="line-820"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-821"></span><span id="local-6989586621679058202"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056510"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058202"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#WrappedMonoid"><span class="hs-identifier hs-type">Semigroup.WrappedMonoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058202"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-822"></span><span>  </span><span id="local-6989586621679056507"><span class="annot"><span class="annottext">get :: Get (WrappedMonoid m)
</span><a href="#local-6989586621679056507"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(m -&gt; WrappedMonoid m) -&gt; Get m -&gt; Get (WrappedMonoid m)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">m -&gt; WrappedMonoid m
forall m. m -&gt; WrappedMonoid m
</span><a href="../../base/src/Data.Semigroup.html#WrapMonoid"><span class="hs-identifier hs-var">Semigroup.WrapMonoid</span></a></span><span> </span><span class="annot"><span class="annottext">Get m
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-823"></span><span>  </span><span id="local-6989586621679056504"><span class="annot"><span class="annottext">put :: WrappedMonoid m -&gt; Put
</span><a href="#local-6989586621679056504"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">(m -&gt; Put) -&gt; (WrappedMonoid m -&gt; m) -&gt; WrappedMonoid m -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">WrappedMonoid m -&gt; m
forall m. WrappedMonoid m -&gt; m
</span><a href="../../base/src/Data.Semigroup.html#unwrapMonoid"><span class="hs-identifier hs-var hs-var">Semigroup.unwrapMonoid</span></a></span></span><span>
</span><span id="line-824"></span><span>
</span><span id="line-825"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-826"></span><span id="local-6989586621679058198"><span id="local-6989586621679058199"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056499"><span class="hs-special">(</span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058199"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058198"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Arg"><span class="hs-identifier hs-type">Semigroup.Arg</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058199"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058198"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-827"></span><span>  </span><span id="local-6989586621679056495"><span class="annot"><span class="annottext">get :: Get (Arg a b)
</span><a href="#local-6989586621679056495"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>                     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b -&gt; Arg a b) -&gt; Get a -&gt; Get b -&gt; Get (Arg a b)
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b -&gt; Arg a b
forall a b. a -&gt; b -&gt; Arg a b
</span><a href="../../base/src/Data.Semigroup.html#Arg"><span class="hs-identifier hs-var">Semigroup.Arg</span></a></span><span> </span><span class="annot"><span class="annottext">Get a
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get b
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-828"></span><span>  </span><span id="local-6989586621679056490"><span class="annot"><span class="annottext">put :: Arg a b -&gt; Put
</span><a href="#local-6989586621679056490"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Semigroup.html#Arg"><span class="hs-identifier hs-type">Semigroup.Arg</span></a></span><span> </span><span id="local-6989586621679056489"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056489"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679056488"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679056488"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056489"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall a. Semigroup a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679056488"><span class="hs-identifier hs-var">b</span></a></span></span></span><span>
</span><span id="line-829"></span><span>
</span><span id="line-830"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-831"></span><span class="hs-comment">-- Non-empty lists</span><span>
</span><span id="line-832"></span><span>
</span><span id="line-833"></span><span class="hs-comment">-- | @since 0.8.4.0</span><span>
</span><span id="line-834"></span><span id="local-6989586621679058195"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056484"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058195"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NE.NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058195"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-835"></span><span>  </span><span id="local-6989586621679056479"><span class="annot"><span class="annottext">get :: Get (NonEmpty a)
</span><a href="#local-6989586621679056479"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-836"></span><span>      </span><span id="local-6989586621679056478"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679056478"><span class="hs-identifier hs-var">list</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get [a]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-837"></span><span>      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679056478"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-838"></span><span>        </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Get (NonEmpty a)
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NonEmpty is empty!&quot;</span></span><span>
</span><span id="line-839"></span><span>        </span><span id="local-6989586621679056477"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056477"><span class="hs-identifier hs-var">x</span></a></span></span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span id="local-6989586621679056476"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679056476"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; Get (NonEmpty a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679056477"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; NonEmpty a
forall a. a -&gt; [a] -&gt; NonEmpty a
</span><a href="../../base/src/GHC.Base.html#%3A%7C"><span class="hs-operator hs-var">NE.:|</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679056476"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-840"></span><span>  </span><span id="local-6989586621679056473"><span class="annot"><span class="annottext">put :: NonEmpty a -&gt; Put
</span><a href="#local-6989586621679056473"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">([a] -&gt; Put) -&gt; (NonEmpty a -&gt; [a]) -&gt; NonEmpty a -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall a. NonEmpty a -&gt; [a]
</span><a href="../../base/src/Data.List.NonEmpty.html#toList"><span class="hs-identifier hs-var">NE.toList</span></a></span></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-843"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-844"></span><span class="hs-comment">-- Typeable/Reflection</span><span class="hs-cpp">

#if MIN_VERSION_base(4,10,0)
</span><span>
</span><span id="line-848"></span><span class="hs-comment">-- $typeable-instances</span><span>
</span><span id="line-849"></span><span class="hs-comment">--</span><span>
</span><span id="line-850"></span><span class="hs-comment">-- 'Binary' instances for GHC's &quot;Type.Reflection&quot;, &quot;Data.Typeable&quot;, and</span><span>
</span><span id="line-851"></span><span class="hs-comment">-- kind-system primitives are only provided with @base-4.10.0@ (shipped with GHC</span><span>
</span><span id="line-852"></span><span class="hs-comment">-- 8.2.1). In prior GHC releases some of these instances were provided by</span><span>
</span><span id="line-853"></span><span class="hs-comment">-- 'GHCi.TH.Binary' in the @ghci@ package.</span><span>
</span><span id="line-854"></span><span class="hs-comment">--</span><span>
</span><span id="line-855"></span><span class="hs-comment">-- These include instances for,</span><span>
</span><span id="line-856"></span><span class="hs-comment">--</span><span>
</span><span id="line-857"></span><span class="hs-comment">-- * 'VecCount'</span><span>
</span><span id="line-858"></span><span class="hs-comment">-- * 'VecElem'</span><span>
</span><span id="line-859"></span><span class="hs-comment">-- * 'RuntimeRep'</span><span>
</span><span id="line-860"></span><span class="hs-comment">-- * 'KindRep'</span><span>
</span><span id="line-861"></span><span class="hs-comment">-- * 'TypeLitSort'</span><span>
</span><span id="line-862"></span><span class="hs-comment">-- * 'TyCon'</span><span>
</span><span id="line-863"></span><span class="hs-comment">-- * 'TypeRep'</span><span>
</span><span id="line-864"></span><span class="hs-comment">-- * 'SomeTypeRep' (also known as 'Data.Typeable.TypeRep')</span><span>
</span><span id="line-865"></span><span class="hs-comment">--</span><span>
</span><span id="line-866"></span><span>
</span><span id="line-867"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-868"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056468"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">VecCount</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-869"></span><span>    </span><span id="local-6989586621679056463"><span class="annot"><span class="annottext">put :: VecCount -&gt; Put
</span><a href="#local-6989586621679056463"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Put) -&gt; (VecCount -&gt; Word8) -&gt; VecCount -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (VecCount -&gt; Int) -&gt; VecCount -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">VecCount -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-870"></span><span>    </span><span id="local-6989586621679056458"><span class="annot"><span class="annottext">get :: Get VecCount
</span><a href="#local-6989586621679056458"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; VecCount
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; VecCount) -&gt; (Word8 -&gt; Int) -&gt; Word8 -&gt; VecCount
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; VecCount) -&gt; Get Word8 -&gt; Get VecCount
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-871"></span><span>
</span><span id="line-872"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-873"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056454"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">VecElem</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-874"></span><span>    </span><span id="local-6989586621679056449"><span class="annot"><span class="annottext">put :: VecElem -&gt; Put
</span><a href="#local-6989586621679056449"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Put) -&gt; (VecElem -&gt; Word8) -&gt; VecElem -&gt; Put
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (VecElem -&gt; Int) -&gt; VecElem -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">VecElem -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-875"></span><span>    </span><span id="local-6989586621679056444"><span class="annot"><span class="annottext">get :: Get VecElem
</span><a href="#local-6989586621679056444"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; VecElem
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; VecElem) -&gt; (Word8 -&gt; Int) -&gt; Word8 -&gt; VecElem
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; VecElem) -&gt; Get Word8 -&gt; Get VecElem
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-876"></span><span>
</span><span id="line-877"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-878"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056440"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">RuntimeRep</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-879"></span><span>    </span><span id="local-6989586621679056412"><span class="annot"><span class="annottext">put :: RuntimeRep -&gt; Put
</span><a href="#local-6989586621679056412"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">VecRep</span></span><span> </span><span id="local-6989586621679056411"><span class="annot"><span class="annottext">VecCount
</span><a href="#local-6989586621679056411"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679056410"><span class="annot"><span class="annottext">VecElem
</span><a href="#local-6989586621679056410"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">VecCount -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">VecCount
</span><a href="#local-6989586621679056411"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">VecElem -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">VecElem
</span><a href="#local-6989586621679056410"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-880"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">TupleRep</span></span><span> </span><span id="local-6989586621679056409"><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621679056409"><span class="hs-identifier hs-var">reps</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621679056409"><span class="hs-identifier hs-var">reps</span></a></span><span>
</span><span id="line-881"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">SumRep</span></span><span> </span><span id="local-6989586621679056408"><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621679056408"><span class="hs-identifier hs-var">reps</span></a></span></span><span class="hs-special">)</span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621679056408"><span class="hs-identifier hs-var">reps</span></a></span><span>
</span><span id="line-882"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">LiftedRep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>
</span><span id="line-883"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">UnliftedRep</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span>
</span><span id="line-884"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">IntRep</span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span>
</span><span id="line-885"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">WordRep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">6</span></span><span>
</span><span id="line-886"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int64Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">7</span></span><span>
</span><span id="line-887"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word64Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">8</span></span><span>
</span><span id="line-888"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">AddrRep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">9</span></span><span>
</span><span id="line-889"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">FloatRep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">10</span></span><span>
</span><span id="line-890"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">DoubleRep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">11</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 807
</span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int8Rep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">12</span></span><span>
</span><span id="line-893"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word8Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">13</span></span><span>
</span><span id="line-894"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int16Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">14</span></span><span>
</span><span id="line-895"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word16Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">15</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 809
</span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int32Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">16</span></span><span>
</span><span id="line-898"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word32Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">17</span></span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#endif
</span><span>
</span><span id="line-902"></span><span>    </span><span id="local-6989586621679056345"><span class="annot"><span class="annottext">get :: Get RuntimeRep
</span><a href="#local-6989586621679056345"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-903"></span><span>        </span><span id="local-6989586621679056344"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056344"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-904"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056344"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-905"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">VecCount -&gt; VecElem -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">VecRep</span></span><span> </span><span class="annot"><span class="annottext">(VecCount -&gt; VecElem -&gt; RuntimeRep)
-&gt; Get VecCount -&gt; Get (VecElem -&gt; RuntimeRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get VecCount
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (VecElem -&gt; RuntimeRep) -&gt; Get VecElem -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get VecElem
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-906"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">TupleRep</span></span><span> </span><span class="annot"><span class="annottext">([RuntimeRep] -&gt; RuntimeRep) -&gt; Get [RuntimeRep] -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get [RuntimeRep]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-907"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">SumRep</span></span><span> </span><span class="annot"><span class="annottext">([RuntimeRep] -&gt; RuntimeRep) -&gt; Get [RuntimeRep] -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get [RuntimeRep]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-908"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">LiftedRep</span></span><span>
</span><span id="line-909"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">UnliftedRep</span></span><span>
</span><span id="line-910"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">IntRep</span></span><span>
</span><span id="line-911"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">6</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">WordRep</span></span><span>
</span><span id="line-912"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">7</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int64Rep</span></span><span>
</span><span id="line-913"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">8</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word64Rep</span></span><span>
</span><span id="line-914"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">9</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">AddrRep</span></span><span>
</span><span id="line-915"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">10</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">FloatRep</span></span><span>
</span><span id="line-916"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">11</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">DoubleRep</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 807
</span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">12</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int8Rep</span></span><span>
</span><span id="line-919"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">13</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word8Rep</span></span><span>
</span><span id="line-920"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">14</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int16Rep</span></span><span>
</span><span id="line-921"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">15</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word16Rep</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 809
</span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">16</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int32Rep</span></span><span>
</span><span id="line-924"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">17</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Get RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word32Rep</span></span><span class="hs-cpp">
#endif
</span><span class="hs-cpp">#endif
</span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Get RuntimeRep
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHCi.TH.Binary.putRuntimeRep: invalid tag&quot;</span></span><span>
</span><span id="line-928"></span><span>
</span><span id="line-929"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-930"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056340"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TyCon</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-931"></span><span>    </span><span id="local-6989586621679056329"><span class="annot"><span class="annottext">put :: TyCon -&gt; Put
</span><a href="#local-6989586621679056329"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span id="local-6989586621679056328"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-932"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConPackage"><span class="hs-identifier hs-var">tyConPackage</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-933"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConModule"><span class="hs-identifier hs-var">tyConModule</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-934"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConName"><span class="hs-identifier hs-var">tyConName</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-935"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; Int
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConKindArgs"><span class="hs-identifier hs-var">tyConKindArgs</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-936"></span><span>        </span><span class="annot"><span class="annottext">KindRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; KindRep
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConKindRep"><span class="hs-identifier hs-var">tyConKindRep</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056328"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-937"></span><span>    </span><span id="local-6989586621679056311"><span class="annot"><span class="annottext">get :: Get TyCon
</span><a href="#local-6989586621679056311"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon
</span><a href="../../base/src/Data.Typeable.Internal.html#mkTyCon"><span class="hs-identifier hs-var">mkTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; Get String -&gt; Get (String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get String
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; Get String -&gt; Get (String -&gt; Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get String
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; Get String -&gt; Get (Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get String
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (Int -&gt; KindRep -&gt; TyCon) -&gt; Get Int -&gt; Get (KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (KindRep -&gt; TyCon) -&gt; Get KindRep -&gt; Get TyCon
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get KindRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-938"></span><span>
</span><span id="line-939"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-940"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056306"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">KindRep</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-941"></span><span>    </span><span id="local-6989586621679056277"><span class="annot"><span class="annottext">put :: KindRep -&gt; Put
</span><a href="#local-6989586621679056277"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepTyConApp</span></span><span> </span><span id="local-6989586621679056276"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056276"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679056275"><span class="annot"><span class="annottext">[KindRep]
</span><a href="#local-6989586621679056275"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056276"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[KindRep] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[KindRep]
</span><a href="#local-6989586621679056275"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-942"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepVar</span></span><span> </span><span id="local-6989586621679056274"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056274"><span class="hs-identifier hs-var">bndr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679056274"><span class="hs-identifier hs-var">bndr</span></a></span><span>
</span><span id="line-943"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepApp</span></span><span> </span><span id="local-6989586621679056273"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056273"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679056272"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056272"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056273"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056272"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-944"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepFun</span></span><span> </span><span id="local-6989586621679056271"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056271"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679056270"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056270"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056271"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621679056270"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-945"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepTYPE</span></span><span> </span><span id="local-6989586621679056269"><span class="annot"><span class="annottext">RuntimeRep
</span><a href="#local-6989586621679056269"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><a href="#local-6989586621679056269"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-946"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#KindRepTypeLit"><span class="hs-identifier hs-type">KindRepTypeLit</span></a></span><span> </span><span id="local-6989586621679056267"><span class="annot"><span class="annottext">TypeLitSort
</span><a href="#local-6989586621679056267"><span class="hs-identifier hs-var">sort</span></a></span></span><span> </span><span id="local-6989586621679056266"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679056266"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><a href="#local-6989586621679056267"><span class="hs-identifier hs-var">sort</span></a></span><span> </span><span class="annot"><span class="annottext">Put -&gt; Put -&gt; Put
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679056266"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-947"></span><span>
</span><span id="line-948"></span><span>    </span><span id="local-6989586621679056229"><span class="annot"><span class="annottext">get :: Get KindRep
</span><a href="#local-6989586621679056229"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-949"></span><span>        </span><span id="local-6989586621679056228"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056228"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-950"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056228"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-951"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [KindRep] -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepTyConApp</span></span><span> </span><span class="annot"><span class="annottext">(TyCon -&gt; [KindRep] -&gt; KindRep)
-&gt; Get TyCon -&gt; Get ([KindRep] -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get TyCon
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get ([KindRep] -&gt; KindRep) -&gt; Get [KindRep] -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get [KindRep]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-952"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepVar</span></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; KindRep) -&gt; Get Int -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get Int
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-953"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; KindRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepApp</span></span><span> </span><span class="annot"><span class="annottext">(KindRep -&gt; KindRep -&gt; KindRep)
-&gt; Get KindRep -&gt; Get (KindRep -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get KindRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (KindRep -&gt; KindRep) -&gt; Get KindRep -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get KindRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-954"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; KindRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepFun</span></span><span> </span><span class="annot"><span class="annottext">(KindRep -&gt; KindRep -&gt; KindRep)
-&gt; Get KindRep -&gt; Get (KindRep -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get KindRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (KindRep -&gt; KindRep) -&gt; Get KindRep -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get KindRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-955"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepTYPE</span></span><span> </span><span class="annot"><span class="annottext">(RuntimeRep -&gt; KindRep) -&gt; Get RuntimeRep -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get RuntimeRep
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-956"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; String -&gt; KindRep
</span><a href="../../base/src/Data.Typeable.Internal.html#KindRepTypeLit"><span class="hs-identifier hs-var">KindRepTypeLit</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeLitSort -&gt; String -&gt; KindRep)
-&gt; Get TypeLitSort -&gt; Get (String -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get TypeLitSort
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">Get (String -&gt; KindRep) -&gt; Get String -&gt; Get KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Get String
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-957"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Get KindRep
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHCi.TH.Binary.putKindRep: invalid tag&quot;</span></span><span>
</span><span id="line-958"></span><span>
</span><span id="line-959"></span><span class="hs-comment">-- | @since 0.8.5.0</span><span>
</span><span id="line-960"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056224"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TypeLitSort</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-961"></span><span>    </span><span id="local-6989586621679056221"><span class="annot"><span class="annottext">put :: TypeLitSort -&gt; Put
</span><a href="#local-6989586621679056221"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitSymbol</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-962"></span><span>    </span><span class="annot"><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitNat</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
</span><a href="Data.Binary.Put.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-963"></span><span>    </span><span id="local-6989586621679056212"><span class="annot"><span class="annottext">get :: Get TypeLitSort
</span><a href="#local-6989586621679056212"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-964"></span><span>        </span><span id="local-6989586621679056211"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056211"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
</span><a href="Data.Binary.Get.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-965"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056211"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-966"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; Get TypeLitSort
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitSymbol</span></span><span>
</span><span id="line-967"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; Get TypeLitSort
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitNat</span></span><span>
</span><span id="line-968"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Get TypeLitSort
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHCi.TH.Binary.putTypeLitSort: invalid tag&quot;</span></span><span>
</span><span id="line-969"></span><span>
</span><span id="line-970"></span><span id="local-6989586621679058188"><span class="annot"><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-type">putTypeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058188"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Put.html#Put"><span class="hs-identifier hs-type">Put</span></a></span></span><span>
</span><span id="line-971"></span><span class="hs-comment">-- Special handling for TYPE, (-&gt;), and RuntimeRep due to recursive kind</span><span>
</span><span id="line-972"></span><span class="hs-comment">-- relations.</span><span>
</span><span id="line-973"></span><span class="hs-comment">-- See Note [Mutually recursive representations of primitive types]</span><span>
</span><span id="line-974"></span><span id="putTypeRep"><span class="annot"><span class="annottext">putTypeRep :: forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var hs-var">putTypeRep</span></a></span></span><span> </span><span id="local-6989586621679056208"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056208"><span class="hs-identifier hs-var">rep</span></a></span></span><span>  </span><span class="hs-comment">-- Handle Type specially since it's so common</span><span>
</span><span id="line-975"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056208"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep (*) -&gt; Maybe (a :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-976"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-977"></span><span class="annot"><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Con%27"><span class="hs-identifier hs-type">Con'</span></a></span><span> </span><span id="local-6989586621679056192"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056192"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679056191"><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621679056191"><span class="hs-identifier hs-var">ks</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-978"></span><span>    </span><span class="annot"><span class="annottext">Word8 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-979"></span><span>    </span><span class="annot"><span class="annottext">TyCon -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056192"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-980"></span><span>    </span><span class="annot"><span class="annottext">[SomeTypeRep] -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621679056191"><span class="hs-identifier hs-var">ks</span></a></span><span>
</span><span id="line-981"></span><span class="annot"><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#App"><span class="hs-identifier hs-type">App</span></a></span><span> </span><span id="local-6989586621679056184"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056184"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621679056183"><span class="annot"><span class="annottext">TypeRep b
</span><a href="#local-6989586621679056183"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-982"></span><span>    </span><span class="annot"><span class="annottext">Word8 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-983"></span><span>    </span><span class="annot"><span class="annottext">TypeRep a -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056184"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-984"></span><span>    </span><span class="annot"><span class="annottext">TypeRep b -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep b
</span><a href="#local-6989586621679056183"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-985"></span><span class="annot"><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-type">Fun</span></a></span><span> </span><span id="local-6989586621679056175"><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621679056175"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span id="local-6989586621679056174"><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621679056174"><span class="hs-identifier hs-var">res</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-986"></span><span>    </span><span class="annot"><span class="annottext">Word8 -&gt; Put
forall t. Binary t =&gt; t -&gt; Put
</span><a href="Data.Binary.Class.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-987"></span><span>    </span><span class="annot"><span class="annottext">TypeRep arg -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621679056175"><span class="hs-identifier hs-var">arg</span></a></span><span>
</span><span id="line-988"></span><span>    </span><span class="annot"><span class="annottext">TypeRep res -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621679056174"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-989"></span><span>
</span><span id="line-990"></span><span class="annot"><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-type">getSomeTypeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span>
</span><span id="line-991"></span><span id="getSomeTypeRep"><span class="annot"><span class="annottext">getSomeTypeRep :: Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var hs-var">getSomeTypeRep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-992"></span><span>    </span><span id="local-6989586621679056172"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056172"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get Word8
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-993"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679056172"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-994"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; Get SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; Get SomeTypeRep) -&gt; SomeTypeRep -&gt; Get SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (*) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-995"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679056171"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056171"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get TyCon
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TyCon</span></span><span>
</span><span id="line-996"></span><span>                </span><span id="local-6989586621679056170"><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621679056170"><span class="hs-identifier hs-var">ks</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get [SomeTypeRep]
forall t. Binary t =&gt; Get t
</span><a href="Data.Binary.Class.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Binary.Get.Internal.html#Get"><span class="hs-identifier hs-type">Get</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-997"></span><span>                </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; Get SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; Get SomeTypeRep) -&gt; SomeTypeRep -&gt; Get SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep Any -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep Any -&gt; SomeTypeRep) -&gt; TypeRep Any -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [SomeTypeRep] -&gt; TypeRep Any
forall k (a :: k). TyCon -&gt; [SomeTypeRep] -&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#mkTrCon"><span class="hs-identifier hs-var">mkTrCon</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621679056171"><span class="hs-identifier hs-var">con</span></a></span><span> </span><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621679056170"><span class="hs-identifier hs-var">ks</span></a></span><span>
</span><span id="line-998"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056168"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056168"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-999"></span><span>                </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056163"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056163"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-1000"></span><span>                </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056168"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1001"></span><span>                  </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-type">Fun</span></a></span><span> </span><span id="local-6989586621679056153"><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621679056153"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span id="local-6989586621679056152"><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621679056152"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-1002"></span><span>                      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621679056153"><span class="hs-identifier hs-var">arg</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg -&gt; TypeRep k -&gt; Maybe (arg :~~: k)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056163"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1003"></span><span>                        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">arg :~~: k
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1004"></span><span>                            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep res -&gt; TypeRep (TYPE r2)
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621679056152"><span class="hs-identifier hs-var">res</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (TYPE r2) -&gt; TypeRep (*) -&gt; Maybe (TYPE r2 :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1005"></span><span>                                </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">TYPE r2 :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; Get SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; Get SomeTypeRep) -&gt; SomeTypeRep -&gt; Get SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (a a) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep (a a) -&gt; SomeTypeRep) -&gt; TypeRep (a a) -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; TypeRep (a a)
forall k1 k2 (a :: k1 -&gt; k2) (b :: k1).
TypeRep a -&gt; TypeRep b -&gt; TypeRep (a b)
</span><a href="../../base/src/Type.Reflection.Unsafe.html#mkTrApp"><span class="hs-identifier hs-var">mkTrApp</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621679056168"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056163"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-1006"></span><span>                                </span><span class="annot"><span class="annottext">Maybe (TYPE r2 :~~: *)
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1007"></span><span>                        </span><span class="annot"><span class="annottext">Maybe (arg :~~: k)
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch&quot;</span></span><span>
</span><span id="line-1008"></span><span>                             </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Found argument of kind:      &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep k -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056163"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1009"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Where the constructor:       &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056168"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1010"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Expects an argument of kind: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621679056153"><span class="hs-identifier hs-var">arg</span></a></span><span>
</span><span id="line-1011"></span><span>                             </span><span class="hs-special">]</span><span>
</span><span id="line-1012"></span><span>                  </span><span class="annot"><span class="annottext">TypeRep k
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Applied non-arrow type&quot;</span></span><span>
</span><span id="line-1013"></span><span>                       </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Applied type: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056168"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1014"></span><span>                       </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;To argument:  &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056163"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-1015"></span><span>                       </span><span class="hs-special">]</span><span>
</span><span id="line-1016"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056133"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056133"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-1017"></span><span>                </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056130"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056130"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-1018"></span><span>                </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056133"><span class="hs-identifier hs-var">arg</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep k -&gt; TypeRep (*) -&gt; Maybe (k :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1019"></span><span>                  </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">k :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-1020"></span><span>                      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056130"><span class="hs-identifier hs-var">res</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep k -&gt; TypeRep (*) -&gt; Maybe (k :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1021"></span><span>                        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">k :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; Get SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; Get SomeTypeRep) -&gt; SomeTypeRep -&gt; Get SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (a -&gt; a) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep (a -&gt; a) -&gt; SomeTypeRep)
-&gt; TypeRep (a -&gt; a) -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; TypeRep (a -&gt; a)
forall k (fun :: k) arg res.
(k ~ *, fun ~~ (arg -&gt; res)) =&gt;
TypeRep arg -&gt; TypeRep res -&gt; TypeRep fun
</span><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-var">Fun</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621679056133"><span class="hs-identifier hs-var">arg</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621679056130"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-1022"></span><span>                        </span><span class="annot"><span class="annottext">Maybe (k :~~: *)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1023"></span><span>                  </span><span class="annot"><span class="annottext">Maybe (k :~~: *)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1024"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; Get SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Invalid SomeTypeRep&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1025"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-1026"></span><span>    </span><span id="local-6989586621679056135"><span class="annot"><span class="annottext">failure :: String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621679056135"><span class="hs-identifier hs-var hs-var">failure</span></a></span></span><span> </span><span id="local-6989586621679056117"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679056117"><span class="hs-identifier hs-var">description</span></a></span></span><span> </span><span id="local-6989586621679056116"><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679056116"><span class="hs-identifier hs-var">info</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1027"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; m a) -&gt; String -&gt; m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String
</span><a href="../../base/src/Data.OldList.html#unlines"><span class="hs-identifier hs-var">unlines</span></a></span><span> </span><span class="annot"><span class="annottext">([String] -&gt; String) -&gt; [String] -&gt; String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHCi.TH.Binary.getSomeTypeRep: &quot;</span></span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679056117"><span class="hs-identifier hs-var">description</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-1028"></span><span>                      </span><span class="annot"><span class="annottext">[String] -&gt; [String] -&gt; [String]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; String) -&gt; [String] -&gt; [String]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    &quot;</span></span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679056116"><span class="hs-identifier hs-var">info</span></a></span><span>
</span><span id="line-1029"></span><span>
</span><span id="line-1030"></span><span id="local-6989586621679058137"><span id="local-6989586621679058138"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056111"><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Typeable"><span class="hs-identifier hs-type">Typeable</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058137"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679058137"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679058138"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1031"></span><span>    </span><span id="local-6989586621679056110"><span class="annot"><span class="annottext">put :: TypeRep a -&gt; Put
</span><a href="#local-6989586621679056110"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span>
</span><span id="line-1032"></span><span>    </span><span id="local-6989586621679056107"><span class="annot"><span class="annottext">get :: Get (TypeRep a)
</span><a href="#local-6989586621679056107"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1033"></span><span>        </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056103"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056103"><span class="hs-identifier hs-var">rep</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-1034"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056103"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; Maybe (a :~~: a)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056102"><span class="hs-identifier hs-var">expected</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1035"></span><span>          </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: a
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; Get (TypeRep a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056103"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1036"></span><span>          </span><span class="annot"><span class="annottext">Maybe (a :~~: a)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; Get (TypeRep a)
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; Get (TypeRep a)) -&gt; String -&gt; Get (TypeRep a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String
</span><a href="../../base/src/Data.OldList.html#unlines"><span class="hs-identifier hs-var">unlines</span></a></span><span>
</span><span id="line-1037"></span><span>                        </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GHCi.TH.Binary: Type mismatch&quot;</span></span><span>
</span><span id="line-1038"></span><span>                        </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Deserialized type: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056103"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1039"></span><span>                        </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Expected type:     &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056102"><span class="hs-identifier hs-var">expected</span></a></span><span>
</span><span id="line-1040"></span><span>                        </span><span class="hs-special">]</span><span>
</span><span id="line-1041"></span><span>     </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679056102"><span class="annot"><span class="annottext">expected :: TypeRep a
</span><a href="#local-6989586621679056102"><span class="hs-identifier hs-var hs-var">expected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TypeRep a
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679058137"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-1042"></span><span>
</span><span id="line-1043"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679056090"><span class="annot"><a href="Data.Binary.Class.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1044"></span><span>    </span><span id="local-6989586621679056089"><span class="annot"><span class="annottext">put :: SomeTypeRep -&gt; Put
</span><a href="#local-6989586621679056089"><span class="hs-identifier hs-var hs-var hs-var hs-var">put</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621679056088"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056088"><span class="hs-identifier hs-var">rep</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; Put
forall {k} (a :: k). TypeRep a -&gt; Put
</span><a href="Data.Binary.Class.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621679056088"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1045"></span><span>    </span><span id="local-6989586621679056087"><span class="annot"><span class="annottext">get :: Get SomeTypeRep
</span><a href="#local-6989586621679056087"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Get SomeTypeRep
</span><a href="Data.Binary.Class.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-1048"></span></pre></body></html>